发表于： 2020-11-22 23:45:45
1 1286
今天完成的事情：
比较一下增强的 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
明天计划的事情：
继续学习基础
遇到的问题：
进度慢，而且对比网站，感觉书中实践类容缺少很多，明天过一遍知识，然后直接开始实践，这样学到东西应该会多一些，进度快。
收获：以上结论
返回列表
评论