发表于: 2020-11-22 23:45:45
1 1285
今天完成的事情:
比较一下增强的 for 循环和一般 for 循环在循环体内对数据修改之后的结果
增强for循环因为内部使用的迭代器进行删除的,而迭代器无法不能采用集合的方法删除,故增强for循环也无法删除集合中的数据,只能遍历。
/*
for (循环变量类型 循环变量名称 : 要被遍历的对象) 循环体
例子中,
1.arr就是为 要被遍历的对象,可以是数组,集合
2.循环变量类型就是这个arr数组的数据类型,即int
3.循环变量名称就是a,这个可以自己定义
*/
//增强for循环
import java.util.ArrayList;
import java.util.Iterator;
public class ForArray {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
System.out.println(list);
//1,普通for循环删除,索引--
for (int i = 0; i < list.size(); i++) {
if ("d".equals(list.get(i))) {//equals(list.get(i)),先获取list中的元素,然后在和"c"进行对比,看是否相等,相等后执行下一个语句
System.out.println(i);
list.remove(i);//--i,是先进行减一运算,意思就是传入remove中的值是2。i--,后缀方式则是使用原来的值,传入remove中的值是3,传出的值2.
//如果不--,就会漏删。这个的意思应该强调使用原来的值,也就是3
System.out.println(i);
}
}
System.out.println(list);
//2.迭代器删除
Iterator<String> it = list.iterator();
while (it.hasNext()){
if ("b".equals(it.next())){
// list.remove("b");//不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
it.remove();
}
}
System.out.println(list);
//迭代器的另一种写法
for (Iterator<String> it2 = list.iterator(); it2.hasNext();){
if ("b".equals(it2.next())){
// list.remove("b");//不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
it2.remove();
}
}
System.out.println(list);
//3.增强for循环,增强for循环不能删除,只能遍历,因为它的底层用的是迭代器,迭代器就不能删除这里也就不能删除
for (String string : list) {
if ("d".equals(string)) {
list.remove("d");
}
}
System.out.println(list);
}
}
/**
* JAVA核心技术
* 3.1 一个简单的Java应用程序
* 1.JAVA对大小写敏感,如果将main修改成Main就会直接无法运行。
* 2.public成为访问修饰符,用来修饰访问的级别,还有private,设置之后其他人无法访问这个类。
* 3.Java源代码文件就是以.Java为后缀名的文件,编译器将这个转换成.class,字节码文件,在Java虚拟机上运行(JVM)
* 4.每个Java程序都会有一个main方法才能运行,通常可以在类中自定义方法,然后在main方法中调用。
* Java中所有函数都属于某个类的方法,因此Java的main方法必须有一个外壳类。
* 5.{}这个通常成为块。“{“ 开始,结束 ”}”
* 6.System.out.println("Hello,World!");这里,使用了System.out调用println方法
* Java通用语法:object.method(parameters(参数))
*
* 3.2 注释
* 这就是注释,注释是一种给人阅读的文本,不是程序的一部分,所以编译器会自动忽略注释。
* 注释还有两种:1.// 2./* + 8/可将一段很长的代码注释起来(这种注释不能嵌套使用)。
* 现在使用的注释可生成文档
*/
public class HelloWorldTest {//驼峰命令法
public static void main(String[] args) {//目前,Java入口程序规定的方法必须是静态方法,方法名必须为main,括号内的参数必须是String数组。
System.out.println("Hello,World!");
System.out.print("Hello");
}
}
/**
* 3.3 数据类型
* 1.八种基本类型,四种整型:int,short,bong,byte,两种浮点型:float,double。
* 一种表示Unicode编码的字符单元的字符类型char,一种表示真值的boolean(主要是判断对错)
*
* 3.3.1四种整型:int,short,bong,byte,没用小数部分的值,可以是负数
* int,最常用,长度超过20亿,表示中国的人数是可以的,但是不能表示在这个星球上的总人数(可以使用long来表示)。
* int和Integer(这是一个包,可表示任意精度)的区别要分清楚,在这里碰到过坑,现在有点忘了。
* byte和short目前没怎么用过,也没碰到过。这个是用于特定的场合,比如底层的文件处理或者大数组
*
* //1.定义 long 型变量,值的末尾需加 'l' 或 'L'。
* //2.整数类型的数据默认是 int 类型,声明为 long 类型时不添加 'l' 或 'L' 不会报错。
* //3.不加 'L' 默认是 int 型,int 转为 long (小转大为自动类型转换)是安全的,所以会自动转,能编译通过。
* //4.当变量值超过了 int 的表数范围时,必须添加 'l' 或 'L' ,否则编译不通过,会报错!
*
* 3.3.2浮点类型 float,double
* float,这个很少用,我没碰到过使用这个的。例子:一般使用在需要快速处理单精度数据的时候
*
* //1.定义 float 型变量,值的末尾需加 'f' 或 'F'。
* //2.浮点类型的数据默认是 double 类型,声明为 float 类型时不添加 'f' 或 'F' 会报错,编译不通过!
* //3.浮点数不加 'F' 默认是 double 类型,double 转 float(大转小为强制类型转换) 可能损失精度,因此不会自动转,编译是通不过的。
*
* double,由于精度是float的两倍,一般称为双精度(1.0000000000)这个用于计算除法时会用到。不适用禁止出现舍入误差的金融计算。
* (2.0-1.1)会出现0.8999999999999999,因为浮点数是采用二进制系统表示,在二进制系统无法精确表示(1/10)
*
* 浮点型常量有两种表示形式:
* ①十进制数形式,如:5.12、512.0f、.512 (必须有小数点)
* ②科学计数法形式,如:5.12e2、512E2、100E-2
*
*3.3.3 char类型
* char类型用来表示单个字符(如中文字符、英文字符、标点符号、转义字符、Unicode 值等)。
* 通常用来表示字符常量。一般不要在程序中使用char类型
* Unicode编码表应该就是用''格式来表示每一个字符,这个格式在Java中属于char类型。
*
*
* 3.3.4 boolean类型
* 布尔类型有两个值,true和false,用来判定逻辑条件。整形和布尔之间不能转换。
* 1.boolean 类型适于逻辑运算,一般用于程序流程控制。
* if 条件控制语句 for 循环控制语句
* while 循环控制语句 do-while 循环控制语句
* 2.boolean 类型变量只允许取值 true 和 false,不能取值为 null。
* 3.不可以使用 0 或非 0 的整数替代 false 和 true,这点和 C 语言不同。
*
*/
public class DateTypeDemo {
public static void main(String[] args) {
//3.3.1四种整型:int,short,bong,byte
// int i = 2000000000000000000;//会报错,Integer number too large(整数太大)
int i = 2000000000;//20亿
short j = 32767;//不能超过这个数
long k = 2000000000;//不加'L',默认是int类型,不超过int的取值范围就不会报错,小转大,自动转,不会损失精度。
long k1 = 9000000000l;//超过int取值范围,需要在值的末尾需加 'l' 或 'L',不然就会报错,小转大不会损失精度。
byte l = 127;//不能超过这个数
//3.3.2浮点类型 float,double
float z = 1.000000789f;//结果1.0000008,只能出现7位。且需要在后面加'f' 或 'F',不然就会报错。
// 浮点型变量默认是double类型,占位8个字节,float类型占4个字节。大转小,会损失精度,属于强制类型转换,所以不会自动转,编译通不过的。
double x = 1.0000000000000085994;//结果1.0000000000000087,出现16位
// float h = x;//Incompatible types. Found: 'double', required: 'float'(不兼容的类型。 找到:“ double”,必填:“ float”)
System.out.println(z);
System.out.println(x);
System.out.println(2.0-1.1);
System.out.println((float) (1/10));//结果应该为0.1,实际结果是0.0
//3.3.3 char类型
//字符型常量的三种表现形式:
//1.字符常量是用单引号 ('')括起来的单个字符,涵盖世界上所有书面语的字符。
char a1 ='a';
// char a2 ='ab';//Too many characters in character literal(Too many characters in character literal)
//char只能放一个字符
char a3 ='中';
// char a4 ='中国';//报错
//2.Java 中还允许使用转义字符 '\' 来将其后的字符转变为特殊字符型常量。
//使用 char 表示转义字符,每一个转义字符都是一个字符
char c1 = '\n'; // '\n' 为换行符
char c2 = '\t'; // '\t' 为制表符,相当于 tab 键
char c3 = '\b';
//3.直接使用 Unicode 值来表示字符型常量:‘’。其中,XXXX代表一个十六进制整数。
char c4 = '\u0008';
//程序中使用 " \ " 来进行符号的转义。
System.out.println(c1+"魏鑫是个\"帅\"哥"); // 帅加个双引号,会换一行
System.out.println(" "+c3+"魏鑫是个\"帅\"哥"); //退一格
System.out.println(" "+c4+"魏鑫是个\"帅\"哥"); //退一格
//3.3.4 boolean类型
boolean b1 = false;
boolean b2 = true;
// boolean b3 = null; //会报错,不兼容类型。boolean不能为空
//不可以使用 0 或非 0 的整数替代 false 和 true,这点和 C 语言不同。x = 0 ;不等于布尔直false
// if(x = 0){
//
// }
}
}
结论:数据类型有 四种整形,两种浮点型,布尔型,字符型,Java程序中,整型默认为int,浮点默认为double.char类型很少在程序中使用,boolean类型一般用于流程控制,for,while,if,do-while
/**
* 3.4 变量
* 在Java中,每个变量是一种类型,变量的类型位于变量名之前
* 1.变量的概念:变量是内存中的一个存储区域,该区域有自己的名称(变量名)和类型(数据类型),该区域的数据可以在同一类型范围内不断变化。
* 2.在 Java 中,对于每一种数据都定义了明确的具体数据类型,在内存中分配了不同大小的内存空间。
* 3.Java 中的每个变量都必须先声明,后使用。
* 3.4.1 变量初始化
* 声明一个变量之后,必须对变量进行初始化赋值,不然变量无法使用
*
*
* 3.4.2常量
* 在Java中,用关键字final指示常量
* 类常量
* 使用关键字static final可以设置一个类常量
* 类常量定义位于main方法的外部,所以在同一个类中的其他方法也已使用这个常量
* 如果一个常量被声明public,其他类中的方法也可以使用这个常量
*
*
*/
public class VariableDemo {
// final double PI = 3.14;//方法中无法被使用,这个应该和static有关,暂时存疑。
static final double PI = 3.14;//需要加上static后,方法中才可以使用PI
// public static final double PI = 3.14;
public static void main(String[] args) {
//3.4 变量
double salary = 5000.0;//薪水
int vacationDays = 2;//休假日
long earthPopulation = 6000000000L; //地球人口
boolean done = true;//完成
int i , j;// 都是整数,不提倡这种风格。逐一声明每一个变量可提高程序得可读性
//这两个是不同的变量名,变量名对大小写敏感
int day;
// int Day;
// Day = 30;
int Day = 30;
Day = 120;
//3.4.1 变量初始化
//需要对变量进行初始化,不然会报错
System.out.println(Day);//Variable 'Day' might not have been initialized(未初始化)
//3.4.2常量
final int ONE = 1;//常量习惯全大写
// ONE = 2;//Cannot assign a value to final variable 'one'(无法为常量赋值)
//类常量,在一个类中的多个方法中使用
double radius = 5 ;
System.out.println("Area="+radius*radius*PI);
show1();
}
private static void show1(){
int h = 10;
double radius = 6 ;
System.out.println("Cylinder volume="+radius*radius*PI*h);
}
}
结论:设置变量之后可在内存开辟空间,存储变量,变量被赋值之后方可使用。变量可重新赋值,等号是赋值语句,不是数学意义的等号。常量在初始化后不可重新赋值,可使用关键字static final设置一个类常量,在方法中可以使用。
/**
* 3.5 运算符
* Java的整数运算遵循四则运算规则,可以使用任意嵌套的小括号。四则运算规则和初等数学一致。
*
* 3.5.1 自增运算符与自减运算符
* 在使用自增/自减运算时应注意下面几个问题。
* 1.自增/自减只能作用于变量,不允许对常量、表达式或其他类型的变量进行操作。常见的错误是试图将自增或自减运算符用于非简单变量表达式中。
* 2.自增/自减运算可以用于整数类型 byte、short、int、long,浮点类型 float、double,以及字符串类型 char。
* 3.在 Java 1.5 以上版本中,自增/自减运算可以用于基本类型对应的包装器类 Byte、Short、Integer、Long、Float、Double 和 Character。
* 4.自增/自减运算结果的类型与被运算的变量类型相同。
* ++n是进行运算时是先进行加1运算,然后在和函数进行计算
* n++则是先用变量的的值和函数进行计算,然后再进行加1计算
*
*
* 3.5.2 关系运算符与boolean运算符(位运算符没有了解)
* 对于布尔类型boolean,永远只有true和false两个值。
*
* 布尔运算是一种关系运算,包括以下几类:
*
* 1.比较运算符:>,>=,<,<=,==,!=
* 2.与运算 &&
* 3.或运算 ||
* 4.非运算 !
*
* 关系运算符的优先级从高到低依次是:
*
* !
* >,>=,<,<=
* ==,!=
* &&
* ||
*
* 结论:对于 && 和 || 而言,只要第一个确认对错,第二个值就不用计算了。这就是按照“短路”求值的方式
*
* 3.5.4 数学函数与常量(仅了解)
* 不用在数学方法名和常量名前添加前缀“ Math.”,在代码最上面导入包就可以了:import static java.lang.Math.*;
*
*
* 3.5.5 数值类型之间的转换
* 1.byte,short,char都可以转换成int,且过程中不丢失精度。
* 2.int可以转换long,double,且过程中不丢失精度(float转double)。
* 3.可能有精度丢失的转换,int转float,long转double,long转float.
*
* 3.5.6 强制类型转换
* xxx m = xxx;
* xxx n = (xxx)m;
* 一般不建议强制转换,因为会丢失信息,数值随之会发生改变,出现意料之外的结果。
* boolean类型不能和任何数值类型之间强制转换
*/
import static java.lang.Math.*;
public class OperatorDemo {
static int i =10;
static double i1 = 10.0;
static int j = 100;
static int k = 100;
public static void main(String[] args) {
// Arithmetic();//四则运算
// SelfChange();//自增运算符与自减运算符
// BooleanDemo();//关系运算符与boolean运算符
// System.out.println(PI);//3.141592653589793
// TypeConversionDemo();//数值类型之间的转换
EnforceTypeConversionDemo();//强制类型转换
}
private static void Arithmetic(){
i += 4;
k %= 50;
System.out.println("i = i + 4="+i);
System.out.println("k = k % 50="+k);
//整除
System.out.println("整除="+i/j);//结果为0
//求余
System.out.println("求余="+i%3);//结果为1
//浮点除法
System.out.println("浮点除法="+i1/j);//结果为0.1
}
private static void SelfChange(){
int m = 7;
int n = 7;
int a = 2;
int b = 2;
i++;
System.out.println(i);//11
// 10++;//Variable expected(需要变量)
j--;
System.out.println(j);//99
System.out.println("前提条件,a=b=2,m=n=7");
a = a * ++m;
System.out.println("采用++m的值="+m);//8
System.out.println(a);//16,++m是进行运算时是先进行加1运算,然后在和函数进行计算
b = b * n++;
System.out.println("采用n++的值="+n);//8
System.out.println(b);//14,n++则是先用变量的的值和函数进行计算,然后再进行加1计算
}
private static void BooleanDemo(){
boolean A = 3 == 7;//false
boolean B = 3 != 7;//true
int age = 10;
//当 && ,左右都正确,最终结果才为正,任何一个错误,都为错
boolean isTeenager = age >=8 && age < 18;//true
boolean isTeenager1 = age >=8 && age > 18;//false
boolean job = age > 18;//false
// || ,任一为正都为正,都错则错
boolean D = age > 20 || age >8;//true
boolean C = age > 20 || age >80;//false
int x =0;
int y = 3;
boolean F = x != 0 && 1/x > x+y;
//三元操作符 ?:。 condition(条件) ? expression : expression(表达式),
//当条件为真时,计算第一个表达式,否则计算第二个表达式
System.out.println(x<y ? x : y);
}
private static void TypeConversionDemo(){
byte m = 127;
int n = m;
n = 187;
System.out.println(n);
int t = 160000000;
long l = t;
float f = t;
double d = t;
//查看一个整数对应的二进制的方法:
System.out.println(Integer.toBinaryString(t));
System.out.println(Integer.toBinaryString((int)l));
System.out.println("double类型:"+d);
System.out.println("float类型:"+f);
System.out.println("float类型:"+t+f);
System.out.println("double类型:"+t+d);
System.out.println("float类型:"+l+f);
}
private static void EnforceTypeConversionDemo(){
double x = 9.997;
int nx = (int)x;
System.out.println(nx);
//将int的值转换成byte,值会改变,因为1byte=8bit,所以byte读取到了整数二进制只能读取8位,故值会发生改变
byte b = 5 ;
int n = 300 ;
b = (byte)n;
//查看一个整数对应的二进制的方法:
System.out.println(Integer.toBinaryString(n));
System.out.println(b);//44
}
}
结论:浮点型计算有误差的存在;因为可以强制转型,但超出范围的强制转型会得到错误的结果;&&和 | | 是短路运算,三元运算b ? x : y后面的类型必须相同,三元运算也是“短路运算”,只计算x或y
明天计划的事情:
继续学习基础
遇到的问题:
进度慢,而且对比网站,感觉书中实践类容缺少很多,明天过一遍知识,然后直接开始实践,这样学到东西应该会多一些,进度快。
收获:以上结论
评论