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 | -2*10^63~2*10^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(inputr) {
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@4554617c
//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，数据是按追加的效果输出，不覆盖文件中的原数据
BufferedWriter – 高效/缓冲字符输出流
构造方法的参数：Writer,抽象父级无法实例化，所以传入的是子级FileWriter
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 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 it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("方式4:");
ListIterator it2 = list.listIterator();
while(it2.hasNext()){
System.out.println(it2.next());
}
}
}
LinkedList:List接口的实现类,底层的数据结构为链表,内存空间是不连续的
(1)元素有下标,有序
(2)允许存放重复的元素
(3)在数据量较大的情况下,查询慢,增删快
package cn.tedu.collection;
import java.util.LinkedList;
/*本类用于测试linkedlist方法的使用*/
public class TestLinkedList {
public static void main(String[] args) {
//1.创建集合对象
LinkedList list = new LinkedList<>();
//2.向集合中添加数据
list.add("孙悟空");
list.add("猪八戒");
list.add("沙悟净");
list.add("唐三藏");
list.add("白龙马");
System.out.println(list);
//3.2测试LinkedList独有的方法
list.addFirst("蜘蛛精");//添加集合头结点
list.addLast("玉兔精");//添加集合尾结点
System.out.println(list);
System.out.println(list.getFirst());//蜘蛛精,获取首个元素
System.out.println(list.getLast());//玉兔精,获取尾元素
System.out.println(list.removeFirst());//删除首元素
System.out.println(list.removeLast());//删除尾元素
System.out.println(list);
//4.其他测试
//4.1创建对象
LinkedList list2= new LinkedList<>();
list2.add("西游记");
list2.add("红楼梦");
list2.add("水浒传");
list2.add("三国演义");
System.out.println(list2);
System.out.println(list2.element());//西游记,获取集合中的首元素
/*别名:查询系列*/
System.out.println(list2.peek());//西游记,获取集合中的首元素
System.out.println(list2.peekFirst());//西游记,获取集合中的首元素
System.out.println(list2.peekLast());//三国演义,获取集合中的尾元素
/*别名:新增系列*/
System.out.println(list2.offer("斗罗大陆"));//添加尾元素
System.out.println(list2.offerFirst("盗墓笔记"));//添加首元素
System.out.println(list2.offerLast("钢铁是怎样炼成的"));//添加尾元素
System.out.println(list2);
/*别名:一出系列*/
System.out.println(list2.poll());//移除首元素
System.out.println(list.pollFirst());//移除首元素
System.out.println(list2.pollLast());//移除尾元素
System.out.println(list2);
}
} 33.泛型
(1)泛型,不是指一种具体的类型,而是说,这里有个类型需要设置,那么具体设置成什么类型,得看具体的使用
(2)泛型通常与集合一起使用,用来限制集合中元素的类型,泛型设置了什么类型,那么这个集合只能存这个泛型类型的数据
(3)泛型是一颗"语法糖"
a.泛型可以把报错的时间提前,用于在编译期检查集合的数据类型,只要不是规定的类型,就报错,通不过编译
b.泛型只在编译时生效,编译通过以后,说明符合语法,泛型就会被抛弃,字节码文件中没有泛型
(4)泛型的类型必须使用引用类型,比如Student,Integer
(5)泛型方法:如果在方法上使用了泛型,必须两处同时出现:
a.一个是方法的参数列表中的参数类型
b.一个是返回值前的泛型类型,表示这是一个泛型方法