2025年CGB第一阶段笔记总结

大家好，我是讯享网，很高兴认识大家。

1.环境变量配置

(1)JAVA_HOME---JDK的安装(创建)

(2)CLASS_PATH--lib(创建)

(3)Path--bin(不创建)

2.JDK,JRE与JVM

(1)JDK--Java开发工具包--想要编写程序,必须安装

(2)JRE--Java运行环境

(3)JVM--Java虚拟机

3.数据类型

(1)基本类型

整数型:byte short int long

浮点型:float double

字符:char

布尔:boolean

(2)引用类型

4.数据类型的规定

(1)整数默认是int类型

(2)浮点默认是double类型

(3)byte,short,char比int小的类型,可以在范围内直接赋值

(4)后缀: L--long F--float D--double

(5)前缀:Ob--二进制 O--八进制 Ox--十六进制

package cn.tedu.basic; /本类用于测试各种类型变量的默认值*/ /总结： * 1.整形类型数据的默认值是0 * 2.浮点型类型数据的默认值是0.0 * 3.布尔类型数据的默认值是false * 4.字符型类型数据的默认值是\u0000，在eclipse中是一个空格 * 5.引用类型【除8大基本类型以外的类型】默认值是null * */ public class TestVariable1 { static String name; static byte a; static short b; static int c; static long d; static float e; static double f; static char g; static boolean h; public static void main(String[] args) { /由于main()方法是被static静态修饰的 * 所以main()想要使用这些变量也得是静态的*/ System.out.println(name); System.out.println(a); System.out.println(b); System.out.println(c); System.out.println(d); System.out.println(e); System.out.println(f); System.out.println(g); System.out.println(h); } }

讯享网

5.++,--

符号在前,先改变变量本身的值,再使用

符号在后,先试用,再改变变量本身的值

6.&的4种情况

1&1=1

1&0=0

0&1=0

0&0=0

7.|的4种情况

1|0=1

0|1=1

1|1=1

0|0=0

8.单分支结构

if(判断条件){

符合判断条件后要执行的代码,如果不符合条件,此句代码会被跳过

}

讯享网package cn.tedu.review; import java.util.Scanner; /本类用于复习分支结构*/ public class TestIf { //0.创建程序的入口函数main public static void main(String[] args) { /1.单分支结构*/ int a = 100; if(a>50&&a<=100) { System.out.println("满50"); } if(a>30&&a<=50) { System.out.println("满30"); } //1.接收用户在键盘输入的代码函数，判断用户的代码熟练度 int num = new Scanner(System.in).nextInt(); System.out.println("请输入代码的行数："); if(num>=70000) { System.out.println("恭喜你，高薪offer正在等待你"); }else {System.out.println("请再接再厉");} } }

9.多分支结构

char  gender =  '男'; if(gender=='男'){ System.out.println("男生可以玩滑板"); }else{ System.out.println("女生可以化妆"); }

10.嵌套分支

if(判断条件1){

满足判断条件1,执行代码1

}else if(判断条件2){

满足判断条件2,执行代码2

}else if(判断条件3){

满足判断条件3,执行代码3

}else{

以上条件都不满足,执行代码4

}

11.switch结构

讯享网switch(Exception){ case value : Syetem.out.println(1) break; case value : Syetem.out.println(2) break; case value : Syetem.out.println(3) break; case value : Syetem.out.println(4) break; default:Syetem.out.println(0) break;

package cn.tedu.review; import java.util.Scanner; /本类用于练习选择结构*/ public class TestSwitch { public static void main(String[] args) { Scanner scan = new Scanner(System.in); System.out.println("请输入您想进入的房间号："); String s = scan.next(); switch(s) { case"天":System.out.println("请玩家进入天字一号房间");break; case"地":System.out.println("请玩家进入地字二号房间");break; case"玄":System.out.println("请玩家进入玄字三号房间");break; case"黄":System.out.println("请玩家进入黄字四号房间");break; default:System.out.println("哪里来的混子，乱棍打出去"); } } }

12.break和continue

(1)break:直接跳出当前for循环,执行此循环外部接下来的代码

讯享网for(){ //代码1...... if(//条件){ //代码3...... break; //代码4...... } //代码2...... }

(2)continue:略过本轮循环continue后半部分代码,直接开始下一轮循环

for(){ //代码1... if(//条件){ //代码3... continue; } //代码2... }

13.8大类型

	字节	默认值	范围	对应关系
byte	1	0	-128~127	Byte
short	2	0	-32768~32767	Short
int	4	0	-21E~21E	Integer
long	8	0L	-210^63~210^63-1	Long
float	4	0.0f		Float
double	8	0.0d		Double
char	2	\u0000	0~65535	Character
boolean	1	false		Boolean

14.方法的格式

public static void main ( String[] args) { }

方法的修饰符方法的返回值类型方法名参数列表方法体

讯享网package cn.tedu.method; /本类用作方法的入门案例*/ public class TestMethod { //1.创建程序的入口函数main public static void main(String[] args) { System.out.println(1); /2.一个方法会不会执行，取决于有没有调用这个方法*/ /我们通过方法名+参数列表来确定要调用哪个方法*/ method1(); System.out.println(2); method2(6); method3(2,5); method4("张三",2.7d); } //需求，创建方法四打印张三今晚要吃2.7碗大米饭 private static void method4(String name, double d) { System.out.println(name+"今晚要吃"+d+"碗大米饭"); } private static void method3(int i, int j) { System.out.println(i*j); } /3.本方法用于测试方法的参数*/ private static void method2(int n) { System.out.println("海绵宝宝今年"+n+"岁啦"); } /1.method1()用于测试方法的调用顺序 * 方法定义的格式 * 修饰符 返回值类型 方法名(参数列表){方法体}*/ private static void method1() { System.out.println(5); System.out.println(6); System.out.println(7); } }

15.while格式

while(执行条件){

循环体;

}

package cn.tedu.basic; import java.util.Random; import java.util.Scanner; /本类用于练习while循环*/ //需求：产生一个随机数，和用户一直输入的数作比较，直到猜对 public class TestWhile { public static void main(String[] args) { //1.生成一个随机数，交给变量r来保存，用来给用户猜 /参数100是自定义的，此时生成的随机数的范围是【0,100】以内的整数，包含0但不包括100*/ int r = new Random().nextInt(100); System.out.println(r); //2.调用一个自定义的猜数字方法 guessNum(r); } //本方法用来完成猜数字的功能 private static void guessNum(int r) { /while(判断是否能继续循环的条件){如果条件的结果为true，执行此处循环体的内容} * 所以，我们用while写死循环，格式：while(true){} * 但是一定注意！！！死循环必须设置程序的出口【循环什么时候结束】*/ while(true) {//设置了一个一直会执行的死循环 //1.接收用户猜的数字 System.out.println("猜猜看"); int input = new Scanner(System.in).nextInt(); //2.判断用户是否猜对 if(input<r) { System.out.println("猜小了"); }else if(input>r) { System.out.println("猜大了"); }else if(input==r) { System.out.println("恭喜你！猜对了！"); break;//当用户猜对了，结束循环，程序结束 } } } }

16.do-while

do{

循环体;

}while(执行条件);

讯享网package cn.tedu.basic; import java.util.Random; /本类用于练习do-while循环*/ public class TextDowhile { public static void main(String[] args) { int n; do { System.out.println("我是循环体"); n=new Random().nextInt(100); System.out.println(n); }while(n>100); } }

17.数组创建的3种方式

(1)int[] a= {1,2,3,4,5};

(2)int[] b= new int[5];

(3)int[] c=new int[]{1,2,3,4,5};

c[0] =1;

c[1]=2;

c[2]=3;

c[3]=4;

c[4]=5;

Syetem,out.println((Arrays.toString(a));//打印

int[] a=Arrays.copyOf(a,5);//a:要复制的数组, 5:新数组的长度

数组名保存的是数组的地址值,不是数组中每一个具体的元素,数组名是一个引用类型的变量

18.面向过程和面向对象

面向过程:是一种思想,强调亲力亲为

面向对象:是一种思想,强调结果

19.面向对象的三大特征

封装,继承,多态

20.栈与队列

栈:先进后出

队列:先进先出

栈与队列指的是一种数据的结构

21.创建对象时,内存经历了什么?

(1).在栈内存中开辟一块空间,存放引用变量P,并把P压入栈底

(2).在栈内存中开辟一块空间,存放Phone对象

讯享网

(3).完成对象的初始化,并赋予默认值

(4).给初始化完毕的对象赋予唯一的地址值

(5).把地址值交给引用类型变量P来保存

22.权限修饰符速查表

修饰符	同类	同包	子类	不同包(无关类)
public	Yes	Yes	Yes	Yes
protected	Yes	Yes	Yes	No
默认	Yes	Yes	No	No
private	Yes	No	No	No

23.执行顺序

(1)构造代码块

(2)构造方法

(3)对象创建成功

(4)普通方法

(5)局部代码块

24.多态的特点

(1).多态的前提一:是继承

(2).多态的前提二:是有方法的重写

(3).父类引用指向子类对象,如Animal a=new Cat();

(4).多态中,编译看左边,运行看右边

25.异常的继承结果

(1)Throwable

--Error:程序解决不了的错误

--Exception:异常,程序可以解决的

--编译时异常:比如:没写分号

--运行时异常:编译时没有问题,一运行就错误

(2)异常的解决方案:捕获,向上抛出

package cn.tedu.exception; import java.util.InputMismatchException; import java.util.Scanner; /本类用作异常的入门案例*/ public class ExceptionDemo { public static void main(String[] args) { //f1();//用来测试异常的暴露 //f2();//异常的解决方案一 //f3();//异常的解决方案二 method();//本方法用来解决f3()抛出的异常 } /*以后这个代码就是别人来写，不是我们自己写*/ private static void method() {//方法用来解决f3()抛出的异常，为了在main()调用之前处理掉这个问题 try { f3(); }catch (Exception e){ System.out.println("输入的不对哦~"); } } /*异常的解决方案二：向上抛出，谁调用这个方法，谁来解决[捕获/抛出] * 格式：在方法里小括号与大括号之间写：throws 异常类型1，异常类型2... * 但是注意：我们一般不把异常直接抛给main(),因为没人解决了，再往后就是JVM虚拟机了 * 所以：我们一般会在main()调用之前解决掉异常*/ private static void f3() throws ArithmeticException{ System.out.println("请您输入要计算的第一个整数："); int a = new Scanner(System.in).nextInt(); System.out.println("请您输入要计算的第二个整数:"); int b = new Scanner(System.in).nextInt(); System.out.println("两个数相除结果为："+a/b); } /*异常的解决方案一：自己捕获处理，格式： try{ 可能会发生异常的所有代码 }catch(异常的类型 异常的名字){ 捕获到了预先推测的异常，就执行此处设置的解决方案 } * */ private static void f2() { //1.编写try-catch结构 try { //2.复写刚刚的代码 System.out.println("请您输入要计算的第一个整数："); int a = new Scanner(System.in).nextInt(); System.out.println("请您输入要计算的第二个整数:"); int b = new Scanner(System.in).nextInt(); System.out.println("两个数相除结果为："+a/b); }catch (ArithmeticException e1){//异常类型 异常名 System.out.println("除数不能为0！");//如果捕获到了算数异常，就执行这句话 }catch(InputMismatchException e2){//异常类型 异常名 System.out.println("请输入整型数据！");//果捕获到了输入不匹配异常，就执行这句话 }catch (Exception e){ /*忽略所有子异常的差异，统一用父类型Exception来接 * 也就是说，不管什么子异常，都能被匹配到，这个是多态最为经典的一种用法*/ System.out.println("输入不正确，请重新输入！");/*提供的通用解决方案*/ } } /*用来暴露异常 * ArithmeticException--输入一个整数，输入一个0，报算数异常，因为除数不能为0 * InputMismatchException--输入一个小数报错，报输入不匹配异常，因为我们要的是整型*/ /*1.不要害怕BUG，真正的勇士敢于直面自己写的BUG * 2.学会看报错的提示信息，确定错误的方向，不管第一行有多长，都得看完 * 3.学会看报错的行号信息，确定自己报错的位置，哪里不对点哪里 * 注意：源码不会错，要看自己的代码*/ private static void f1() { //需求：接收两个整数，打印他们除法的结果 //1.提示接收用户输入的两个整数 System.out.println("请您输入要计算的第一个整数："); int a = new Scanner(System.in).nextInt(); System.out.println("请您输入要计算的第二个整数:"); int b = new Scanner(System.in).nextInt(); //2.输出两个数除法的结果 System.out.println("两个数相除结果为："+a/b); } }

26.进制

2进制:0,1

8进制:0,1,2,3,4,5,6,7

10进制:0,1,2,3,4,5,6,7,8,9

16进制:0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F

27.常用方法

(1)hashCode()作用:返回对象对应的哈希码值

(2)toString

重写前:打印对象的地址值

重写后:打印类型+属性+属性值

(3)equals()

重写前:==比较,比较的是两个对象的地址值

重写后:比较两个对象的类型+属性+属性值

讯享网package cn.tedu.api; import java.util.Objects; /本类用于顶级父类Object的入门案例*/ //1.查API手册 //2.连点两下Shift打开IDEA的搜索,搜Object //3.按住Ctrl点hashCode() //4.在拓展库External Libraries找到jdk1.8->rt.jar->java.lang.Object public class TestObject { public static void main(String[] args) { Student s = new Student(); Student s1 = new Student("海绵宝宝",3); Student s2 = new Student("海绵宝宝",3); //5.测试hashCode() /*本方法的作用是返回对应对象的int类型的哈希码值 * 本方法力求不同的对象返回的哈希码不同 * 这样我们就可以根据哈希码值区分不同的对象*/ System.out.println(s.hashCode()); System.out.println(s1.hashCode()); System.out.println( s2.hashCode()); //6.测试toString() /*Object中toString()的默认实现:对象的名字@+十六进制的哈希码值 * 子类重写了toString()以后:打印的是对象的类型+属性+属性值*/ System.out.println(s);//cn.tedu.api.Student@1b6d3586 System.out.println(s1);//cn.tedu.api.Student@c //8.测试equals() /*Object中equals()的默认实现使用的是==比较 * ==比较的是左右两边的值,如果是基本类型,比较的是字面值,比如1和1,3.4和3.4 * 如果是引用类型,比较的是引用类型变量保存的地址值*/ System.out.println(s1.equals(s2)); System.out.println(s.equals(s1)); } } //1.创建一个学生类 class Student{ //2.定义属性 String name; int age; //3.1添加无参构造 public Student(){ System.out.println("我是Student类的无参构造"); } //3.2添加全参构造 public Student(String name, int age) { this.name = name; this.age = age; System.out.println("我是Student类的全参构造"); } //7.在Student类中添加重写的toString() //右键->Generate->toString() @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } //9.添加重写的equals与hashCode() /*equals()与hashCode()逻辑要保持一致,要重写都重写,要不重写都不重写 * 如果不重写:hashCode()的哈希码根据地址值生成 * equals()底层使用==比较两个对象的地址值 * 如果重写了:hashCode()的哈希码值根据重写传入的属性值生成 * equals()比较的是重写后的类型 + 所有属性与属性值*/ @Override public boolean equals(Object o) { //前提:this代表的是调用本方法对象s1 o代表的是传入的 //1.比较的是两个对象的地址值 if (this == o) return true; //2.1如果传入的对象是null,说明实际上并没有对象,还是引用类型的默认值 //2.2如果两个对象获取类型不一致,比如一个是Cat类型,一个是Car类型 //以上两种情况只要满足一种 if (o == null || getClass() != o.getClass()) return false; //3.传入的对象类型是Object,父类无法使用子类的特有属性,所以需要强转 /*多态:向上造型:把子类看做是父类型,花木兰替父从军 Animal a = new Cat(); * 向下造型:之前转成父类型的子类对象,又想使用子类自己的特有功能了,可以向下转型 ,写法:Cat c = (Cat) a;*/ //向下造型:把父类型Object转回子类型Student Student student = (Student) o; //4.比较的是两个对象的属性与属性值 //如果是基本类型,直接比较值,所以用==比较 //如果是引用类型, return age == student.age && Objects.equals(name, student.name); } @Override public int hashCode() { return Objects.hash(name, age); } }

28.流的分类

(1)按流的方向

输入流:数据从磁盘(文件)到内存(程序)

输出流:数据从内存(程序)到磁盘(文件)

(2)按操作数据的单位

字节流:什么类型的东西都可以处理,包括文档,音频,视频等

字符流:只能处理与字符相关的内容

29.IO流

(1)字节输入流InputStream--抽象父类,不可实例化

FileInputStream--普通子类,构造函数参数类型:File对象/String路径名

BufferedInputStream--普通子类,构造函数参数类型:InputStream,但是抽象父类无法实例化,所以我们传子类对象

package cn.tedu.io; import jdk.internal.util.xml.impl.Input; import java.io.*; /本类用于测试字节输入流*/ public class TestIn { public static void main(String[] args) { //method1();//使用普通的字节输入流读取文件 method2();//使用高效的字节输入流读取文件 } private static void method2() { //定义一个在本方法中都生效的局部变量 InputStream in = null; //1.创建流对象 try { //InputStream in =new BufferedInputStream(new FileInputStream(new File("D:\\ready\\1.txt"))); in =new BufferedInputStream(new FileInputStream("D:\\ready\\1.txt")); //2.使用流对象 int b; while((b=in.read())!=-1){ System.out.println(b); } } catch (IOException e) { e.printStackTrace(); }finally { try { in.close(); } catch (IOException e) { e.printStackTrace(); } } } private static void method1() { //1.定义一个在本方法中都生效的局部变量,局部变量必须手动初始化 InputStream in = null;//引用类型的默认值都是null try { //1.创建流对象--字节输入流InputStream--抽象父类不可实例化 //FileInputStream--插在文件上队对文件操作的字节输入流 //注意:创建的时候会抛出异常,要try-catch // InputStream in = new FileInputStream(new File("D:\\ready\\1.txt")); in = new FileInputStream("D:\\ready\\1.txt"); //2.1使用流对象 /*read()一次只能读取一个字符,并且这个方法的返回值类型是int * 也就是说会到码表中查看字符对应的编码,比如读到字符a,控制台打97 * 如果文件里没有数据,也就是读到了文件的末尾,这个方法返回-1*/ // System.out.println(in.read()); // System.out.println(in.read()); // System.out.println(in.read()); // System.out.println(in.read()); // System.out.println(in.read()); //2.2优化刚刚读取的代码 //需求:需要使用循环结构读取文件中的所有内容,直至读完 //定义变量,用来保存读到的数据 int b; while((b=in.read())!=-1){ System.out.println(b);//打印本轮循环中读到的数据 } //这种写法是错误的,read()每执行一次,就会向后读取一个字节 //那这样while判断读取了一个,打印时,又读取了一个,所以会出现跳着读的现象 // while((in.read())!=-1){ // System.out.println(in.read()); // // } } catch (IOException e) { e.printStackTrace();//如果捕获到异常,打印错误信息到控制台 }finally{ /*finally()代码块是try-catch结构中最后一个部分,这个部分的代码不论是否发生异常,一定会执行 * 我们常在finally{}中添加一些必须执行的操作,比如关流*/ //3.用完流对象以后,一定要关闭流对象!!! try { in.close();//关流操作也有可能抛出异常,所以需要继续try-catch } catch (IOException e) { e.printStackTrace(); } } //3.关闭流对象 } }

(2)字符输入流Reader--抽象父类,不可实例化,构造函数参数类型:File对象/String路径名

FileReader--普通子类--操作文件的字符输入流,构造函数参数类型:InputStream,但是抽象父类无法实例化,所以我们传子类对象

讯享网package cn.tedu.io; import java.io.*; /本类用于练习字符输入流*/ public class TestIn2 { public static void main(String[] args) { //method1(); //用于测试普通字符输入流对象 method2();//用于测试高效字符输入流对象 } private static void method2() { BufferedReader in = null; try { //1.创建高效字符输入流对象 //in = new BufferedReader(new FileReader(new File("D:\\ready\\1.txt"))); in = new BufferedReader(new FileReader("D:\\ready\\1.txt")); //2.使用流对象 int b; while((b=in.read())!=-1){ System.out.println(b); } } catch (Exception e) { e.printStackTrace(); }finally{ try { //3.关流 in.close(); } catch (IOException e) { e.printStackTrace(); } } } private static void method1() { FileReader in =null; //1.创建流对象 try { //我们现在使用的这个FileReader是 抽象父类字符输入流Reader的子级 //FileReader in1 = new FileReader(new File("D:\\ready\\1.txt")); in = new FileReader("D:\\ready\\1.txt"); //2.使用普通字符输入流对象 int b; while((b=in.read())!=-1){ System.out.println(b);} } catch (Exception e) { e.printStackTrace(); }finally{ try { //3.关流 in.close(); } catch (IOException e) { e.printStackTrace(); } } } }

(3)字节输出流:OutputStream--抽象父类,不可实例化

FileOutputStream--普通子类,操作文件的字节输入流,构造函数:FileOutputStream(File file)/FileOutputStream(String name)

BufferedOutputStream--普通子类,高效字节输入流,构造函数:BufferedOutputStream(OutputStream out)

package cn.tedu.io; import java.io.*; /本类用于测试字节输出流*/ public class TestOut { public static void main(String[] args) { //method1();//用于测试普通字节输出流 method2();//用于测试高效字节输出流 } private static void method2() { BufferedOutputStream out =null; try{ //out = new BufferedOutputStream(new FileOutputStream(new File("D:\\ready\\5.txt"))); out =new BufferedOutputStream(new FileOutputStream("D:\\ready\\5.txt",true)); out.write(100); out.write(101); out.write(102); }catch(Exception e){ e.printStackTrace(); }finally{ try { out.close(); } catch (IOException e) { e.printStackTrace(); } } } private static void method1() { FileOutputStream out =null; try{ //out = new FileOutputStream(new File("D:\\ready\\5.txt")); /*FileOutputStream 有一个重载的构造函数,第二个参数是boolean append * 默认为false,如果不写,表示创建的对象是覆盖输出数据的 * 如果我们手动将append的值设置为true,表示创建的流对象是追加输出数据的 * FileOutputStream(File file)--默认覆盖 * FileOutputStream(File file,boolean append)-append为true表示追加输出数据*/ out = new FileOutputStream("D:\\ready\\5.txt",true); //4.使用输出流对象将指定的数据输出到文件中 out.write(97); out.write(98); out.write(99); }catch(Exception e){//异常类型 异常名 e.printStackTrace();//如果捕获到了异常,会在控制台打印错误信息 }finally{//用来关流 try { out.close(); } catch (IOException e) { e.printStackTrace(); } } } }

(4)字符输出流:Writer --抽象父类,不可实例化

FileWriter – 操作文件的字符输出流,构造函数参数类型：File file / String filename
注意：除了上述两个构造方法以外，文件字符输出流对象创建的时候还可以指定输出的方式
默认存在一个参数boolean append,默认值为false，默认覆盖
如果将这个append的值设置为true，数据是按追加的效果输出，不覆盖文件中的原数据

讯享网package cn.tedu.io; import java.io.*; /本类用于练习字符输出流*/ public class TestOut2 { public static void main(String[] args) { method1();//本方法用于测试普通字符输出流 //method2();//本方法用于测试高效字符输出流 } //使用高效的字符输出流FW进行输出-Writer[抽象父类] private static void method2() { //1.创建一个在方法中都生效的局部变量,并给他进行初始化 Writer out = null; try{ // out = new BufferedWriter(new FileWriter(new File("D:\\ready\\2.txt"))); //out = new BufferedWriter(new FileWriter(new File("D:\\ready\\2.txt"),true)); //out = new BufferedWriter(new FileWriter("D:\\ready\\2.txt")); out = new BufferedWriter(new FileWriter("D:\\ready\\2.txt",true)); out.write(100); out.write(100); out.write(100); out.write(100); out.write(100); out.write(100); }catch(Exception e){ e.printStackTrace(); }finally{ try { out.close(); } catch (IOException e) { e.printStackTrace(); } } } //使用普通的字符输出流FW进行输出--Writer[抽象父类] private static void method1() { //1.创建一个在本方法中都生效的局部变量 Writer out = null; //2.完成try-catch-finally结构,因为IO操作会抛出异常 try{ //3.创建普通的字符输出流对象 //out =new FileWriter(new File("D:\\ready\\2.txt"));//覆盖效果,append默认为false //out =new FileWriter(new File("D:\\ready\\2.txt",append true));//追加效果 //out = new FileWriter("D:\\ready\\2.txt");//覆盖效果,append默认为false out = new FileWriter("D:\\ready\\2.txt",true);//追加效果 //4.使用流对象完成输出的操作 out.write(98); out.write(98); out.write(98); out.write(98); }catch(Exception e){ e.printStackTrace(); }finally{ try { out.close(); } catch (IOException e) { e.printStackTrace(); } } } }

30.序列化

31.JAVA常用集合关系

32. List接口的两个常用实现类

ArrayList:List接口的实现类,底层的数据结构为数组,内存空间是连续的

(1)元素有下标,有序

(2)允许存放重复的元素

(3)在数据量较大的情况下,增删慢,查询快

package cn.tedu.collection; import java.util.ArrayList; import java.util.Iterator; import java.util.ListIterator; /*/ public class TestArrayList { public static void main(String[] args) { //1.创建集合对象 ArrayList<Integer> list = new ArrayList<>(); list.add(100); list.add(200); list.add(300); list.add(400); list.add(400); list.add(300); System.out.println(list);//打印查看集合中的元素 //3.测试常用方法 //list.clear(); System.out.println(list.contains("100"));//false,因为这个100是字符串 System.out.println(list.get(1));//200,获取指定下标处的元素 System.out.println(list.indexOf(400));//3 System.out.println(list.lastIndexOf(400));//4 System.out.println(list.remove(0));//删除集合中0号索引处的元素 //System.out.println(list.remove(300));//报错,数组下标越界 /*我们集合中存入的数据是引用类型,不是基本类型 * 所以如果想根据元素删除数据,需要把int类型参数300转为集合中元素的类型Interger*/ System.out.println(list.remove(Integer.valueOf(300))); System.out.println(list); System.out.println(list.size());//获取集合中元素的个数 System.out.println(list.set(0,77));//修改正定位置的值 System.out.println("方式1:"); for (int i = 0; i <list.size() ; i++) { System.out.println(list.get(i)); } System.out.println("方式2:"); for(Integer num:list){ System.out.println(num); } System.out.println("方式3:"); Iterator<Integer> it = list.iterator(); while(it.hasNext()){ System.out.println(it.next()); } System.out.println("方式4:"); ListIterator<Integer> it2 = list.listIterator(); while(it2.hasNext()){ System.out.println(it2.next()); } } }

LinkedList:List接口的实现类,底层的数据结构为链表,内存空间是不连续的