JAVA笔记

FOR的使用

1. for(int=1; i<=10;i++``){syso}

2. for 和 while 的区别：for里的int 是在括号里的，在循环内部，不会被自动回收，提高内存使用效率。 while 里的int变量是不会被回收的。

3. do while: 先执行后判断，至少执行一次。

   while：先判断后执行

   补充

   • 八大基本类型：1.整数：long short int 2. 小数 float double 3.字节：byte 字符：char 布尔值：boolean

   • float和double不能放在一起 float a=2.33f; double b=2.33;

   • long有八个字节，int有四个

   • long c=5； int d=(long) c; 强制类型转变

   • 1byte=8bit

   • 强制类型转变： 类型 变量名=（要被转化的类型）值

     如：int a=(long)10;

     • break：结束当前循环 注：多层循环需要添加标签，标明跳到哪

     • continue：跳过当前循环

     • return：结束一个方法，结束所有

     • i++：先执行再加一次 ++i：先加一次再执行

     • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1zS11xpO-1626426859709)(D:\笔记图片\i++.PNG)]

• 比较大小的图片

  短路效应

  • &&：双个代表只会判断前一个，若符合条件则后一个不会被执行，容易造成短路效应
    • &：单个的前后两个都会执行一次

java概述

面向对象的编程语言

JAVA三个体系

• JavaSE--------客户端
• JavaEE--------（Enterprise Edition）企业版、网站、服务端 EE包含SE
• JavaME-------移动端

JAVA与C++的不同及JAVA的优点

• C++是面向过程的编程语言
• JAVA可以 垃圾自动回收
• JAVA可以 多线程（多个任务同时进行）
• 跨平台（环境不同一样可以运行），一次编译，到处运行

JAVA环境安装

• 找到环境变量，编辑系统变量

  • 变量名命名为：JAVA_HOME
  • 变量值为JDK的下载路径，进入到能看到bin的目录，不进bin

• 修改系统变量中的path，复制：%JAVA_HOME%\bin 及 %JAVA_HOME%\jre\bin

  • 注：WIN7两句话需要用分号隔开

• 验证是否安装完成，打开小黑窗，分别输入java javac

• eclipse安装企业版的，就是Enterprise

Eclipse基本使用方法

• 隐藏左方行数：空白区域,右键————Show Line Numbers

• 挑选最下方的视窗： Window–Show View

• 格式化：Source----Format

小知识点：

• 自己写的代码是 .JAVA，经过编译之后是 .class

• 输出语句中 System.out.println();的换行，是在打印完括号内的内容后才进行换行

• 自己命名的标识符不能用数字打头，且不能是JAVA里的关键字（如： int int=1),这样是不行的

• 在使用long时，如果超过了Int的表示范围，即超过21亿的范围，需要在赋值后面加上大写L（如：long a=222L），小数的float在赋值时也需要加上f。

• a++与++a：

  • a++是先执行一次a，再对a进行加一
  • ++a先对a进行加一，再执行a

• 快捷键：ctrl+alt+↓是快速复制选中行 Ctrl+d是删除 Alt+↑是往上对调换位置

八大基本类型

八大基本类型

• 整数：

  • short 2个字节，默认值0 ，占8个bit
  • int 4个字节，默认值0， 占16个bit
  • long 8个字节，默认值0L，占32个bit

• 小数：

  • float 4个字节，默认值0.0f
  • double 8个字节，默认值0.0d

• 字节： byte 1字节，默认值0，表示范围为 -128~127

• 字符：char 2字节 表示范围为 0~65535

• 布尔值：Boolean 理论上是1bit，但单个 使用往往占4个字节，具体视所处编译环境。

int和char依据ASCII表可以相互转换

char i=97，使用输出语句后输出的是字母a ，就是依据ASCII表找出97对应的字母。

二进制

由1开始，之后呈2的指数倍增加

8 4 2 1

• 0001————1
• 0010————2
• 0100————4
• 1000————8
• 1000 0————16
• 1000 00————32

用二进制表示15为：1+2+4+8 即为1111

用二进制表示127为：128-1 即为10000000-0001 01111111

运算符

• 除法中使用int时：

  • int a=9; int b=6; int c=a/b; System.out.println©; 答案为1.
  • 因为c是整数，所以除法不能整除时，只输出商

• 取余时：

  • x%?= 结果的范围是 0~x-1
  • 想要有x种情况，就对x+1取余

缩写

• a=a+1 可以写为 a++
• a=a+6 可以写为 a+=6

switch

语句：

int task=5;

switch(task){

case 1:

​ System.out.println(“登录功能”);

​ break;

case 2:

​ System.out.println(“2222”);

​ break;

default:

​ System.out.println(“默认”);

​ break;

}

IF主要用来判断是或者不是，如果是会…不会的话会…，switch用于明确情况的判断，确认执行的是哪一种命令。并且switch是不能写范围的，比如成绩在某某之间。

while循环

语句：

int j=1;

while(j<=10){

​ System.out.println(111);

​ j++;

}j++写在花括号里面

for循环和while循环的区别：

JAVA的垃圾自动回收机制，for循环的Int定义在小括号里面，出了小括号后面的代码访问不到，性能角度看for循环的效率更高一点，不会创作许多无用的变量。while循环的Int定义变量在花括号外面，后面的代码可以访问到。

do while循环：

int k=1;

do{

​ System.out.println();

​ k++;

}while(k<=10);

死循环

• for(;😉{

  ​ System.out.println();

  }

• while(true){

  ​ System.out.println();

  }

跳出循环：

• break:

  • 跳出（结束）当前循环
  • break标签**（用于跳出多重嵌套循环）**： 在想要结束的位置加上标签和冒号，之后在break后面写上标签名

• continue：

  • 跳过当前循环

• return：

  • 结束当前方法，后面所有的代码没有意义，系统会提醒删掉

数组

属于引用类型

一维数组：

语法：

• Int[] a;
• int a[];

数组必须初始化才能使用

• 静态初始化：

  • int[] a={1,3,4,5};

• 动态初始化：

  • int[] b=new int[3];
  • b[0]=1; b[2]=5; 给元素赋值

• 获取数组的某一个元素：

  • System.out.printlin(a[0]);

获取每一个元素：

• for(int i=0;i<=a.length();i++){

​ System.out.println(a[i]); }

• 倒叙输出：

  • for(int i=a.length()-1;i>=0;i–){

    System.out.printlin(a[i]); }

二维数组

语法：

• int[] [] a;
• int b[] [];
• int[] c[];

初始化：

• 静态初始化：

• Int[] [] a={{1,2,3},{4,5},{8}};

• 动态初始化：

• int[] [] b=new int[5] [];

• 获取二维数组中的每一个元素：

  for(int i=0;i<a.length();i++){

  ​ for(int j=0;j<a[i].length();j++) {

  ​ System.out.print(a[i] [j]); }

  ​ System.out.prinln(); }

Date类：

Date date=new Date();

System.out.println(date); 直接得到当前日期

System.out.println(date.getTime()); 返回毫秒值

日期格式化

日期转换成字符串：

Date date=new Date();

SimpleDateFormat dateFormat= new SimpleDateFormat(“yyyy-MM-dd”);

String aa=dateFormat.format(date);

System.out.println(aa);

字符串转换成日期：

String aa=“2000-11-11”;

SimpleDateFormat dateFormat= new SimpleDateFormat(“yyyy-MM-dd”);

Date brith=dateFormat.parse(aa); 这里需要抛出异常

System.out.println( brith);

Calendar

语句：

​ Calendar calendar=Calendar.getInstance();

• 这里不需要new一个Calendar，getInstance表示初始化这个类

• Calendar和Date都是表示日期的工具，他们可以相互转换。

Calendar类提供的常用方法：

• calendar.add(Calendar.DATE,2);

  ​ 小括号内，逗号前的表示要修改的属性，后面数字写要修改的值

​ System.out.println(calendar.get(Calendar.DATE));

Random

语句：

​ Random random=new Rondom();

next:

• random.nextInt();

  • 返回int范围之内的一个随机数

• random.nextInt(100);

  • 返回0~100以内的一个数，但是不包括100

Bigdecimal

补：round是四舍五入，floor是向下取整

• double、float浮点数在进行基本运算时会发生数据丢失现象，需要用到bigdecimal。

语法：

​ Bigdecimal decimal=new Bigdecimale(12.5);

方法：

decimal.add(new Bigdecimal(3.5));

add是增加，指在decimal赋值基础上增加3.5

加减乘除的方法：

• add() 加法
• subtract() 减法
• multiply() 乘法
• divide() 除法
• pow(int n) 取余

System

方法：

• System.getenv(“path”);
• System.getProperty(“user.name”);
• System.getProperty(“os.name”);
• System.currentTimeMillis();
  • 得到当前系统的毫秒值

String

String是一个类，类才有对应的方法，不需要new，基本类型是一个关键字，没有对应的方法。

方法：

String aaa=“abcdef”;

• System.out.println(aaa.charAt(2));

  • charAt()是在括号内写上索引，返回对应的字符

• System.out.println(aaa.contains(“abc”));

  • contains()是在括号内写上内容，判断aaa字符串中是否包含，返回的是布尔值，判断为true或者false
  • 也可以用indexof()查找字符串中是否包含某些字符，如果返回-1，就是不包含

• System.out.println(aaa.endsWith());

  • endsWith()是在括号写上内容，判断aaa字符串中是否是以输入内容为结尾,返回布尔值

• System.out.println(aaa.equals());

  • equals()是判断输入的内容是否和aaa中的内容完全相等，返回的是布尔值
  • 不等于是 !aaa.equals(bbb)

• System.out.println(aaa.equalsIgnoreCase());

  • 注：Ignore是忽略，Case是大小写
  • equalsIgnoreCare()是判断内容是否相同，但是忽略了大小写

• System.out.println(aaa.indexof());

  • indexof()是在括号内写上字符，返回对应的索引
  • 注：括号内不论写多少字符，返回的只有第一个字符对应的索引，如果写出的字符，在字符串中查找不出，则返回负数

• System.out.println(aaa.isEmpty());

  • isEmpty()判断字符串是否为空
  • 注：bbb="" 与 bbb=null是不同的，只有前者可以用isEmpty()作判断

• System.out.println(aaa.replace(旧的字符,新的字符));

  • replace()是替换，在逗号前输入旧的，即原本就有的字符，在逗号后输入新的，完成替换
  • 注：替换完成后，原本的字符串并没有改变，而是创造了一个新的字符串，需要新命名来接收新的字符串

• System.out.println(aaa.split(","));

  • String names=“tom,jack,amy,daming”
  • split()是分割字符串，在括号内写上分割的依据，例如names字符串是根据逗号来隔开
  • 接收分割好的字符串时，用数组来接收：String[] name=names.split(",");

• System.out.println(aaa.substring(2,7));

  • substring()是截取字符串，中间可以加逗号填写两个数字，前面的数字表示从哪个字符开始截取，后面的表示截取到哪里，但是**包前不包后，**后面的索引对应的字符是不会被打印的

• System.out.println(aaa.toCharArray());

  • toCharArray()返回的是数组，需要创建数组来接收：char[] array=aaa.toCharArray();之后需要用for循环一个一个打印出来：for(int i=0;i<array.length();i++){System.out.println(array[i]);}

• System.out.println(aaa.toLowercase());

  • toLowerCase()是把整个字符串转化成大写，与之相反是toUpperCase

• System.out.println(aaa.trim());

  • trim()是去除空格,但并不是去除所有空格，只能去除前后的空格，在字符串中间的空格并不会被去除

String 的内存结构

如：String a=“hello”； a=“bye”;

在这个过程中，a的值发生了变化，但是并没有改变hello本身，在常量池中，hello和bey同时存在，只是hello的路径并不指向a，改为bye的路径指向了a

hello一直存在，就算a的值发生了变化，但hello并没有消失，这就叫做String定义的字符串为一个常量，一旦被赋值，不可被改变**

使用String a=“hello”;定义字符串时，系统会先去堆内存（常量池）中查找有没有hello存在，如果有则会直接返回该对象的地址，如果没有，则新建该对象再返回地址值。

如：String a=“hello”; String b=“hello”;

hello在之前a的部分已经被创建过一次了，所以后面b的hello与a的hello是一样的，a与b同时指向一个hello，在常量池中不会存在两个hello

如果使用new String(“hello”); 会创建两个对象，new String()的部分会在堆内存中，"hello"会在常量池，同时，不管new String()多少次，堆内存中都会创建多个new String()

注：对于引用类型来说：==判断的是地址是否一样，equals方法是判断内容是否一样

重点：字符串如果是变量相加，先开空间，再拼接内容，既然开辟空间，那么地址一定不同 字符串如果是常量相加，先拼接，然后再常量池找，如果有就直接返回，没有再创建

StringBuffer和StringBuilder

与String相比是可变的字符串

两者的区别：前者是线程安全的可变字符串，但是效率低，时间长。

​ 后者线程不安全，但是效率高，时间短

buffer表示缓冲的意思

构造方法：

• StringBuffer buffer=new StringBuffer();

• StringBuffer buffer2=new StringBuffer(“12345”);

• StringBuffer buffer3=new StringBuffer(60); 数字表示多大的容量，buffer3可以放多少数字

常见方法：

• 添加：

  • append
    • buffer.append(“hello”);
  • insert
    • buffer.insert(3,“123”);
    • 表示在索引为3的地方插入123

• 删除：

  • deleteCharAt
    • buffer.deleteCharAt(0);
    • 表示删除索引为0的字符
  • delete
    • buffer.delete(0,3);
    • 表示从索引为0的地方删除到索引为3的地方，同样的包前不包后

• 替换

  • replace

• 反转

  • reverse
    • buffer.reverse();
    • 将字符串反转，倒过来

String与StringBuffer的互相转变

String bbb=buffer.toString();

将数字转变为字符串：

String a=String.valueOf(b);

Scanner

• 键盘输入：

​ Scanner scanner=new Scanner(System.in);

• 方法：
  • int aa=scanner.nextInt(); 表示接收数字
  • String aa=scanner.nextLine(); 表示接收字符串
  • 等等等等…

需要注意的坑：

• 使用 String aa=scanner.next();一样可以接收字符串，但是它不会接收空格，只接收第一个空格之前的内容
• 在使用对应的方法时，如：sacnner.nextInt(); 只接收整数的部分，后面的符号、小数、字符串等不会被接收
• 如果在上一步接收时，输入了数字及回车，nextInt的部分只接收数字，回车会被下一行的nextLine();接收到，进行一次回车，所以在看到结果时相当于跳过了nextLine()的部分
  • 针对上述问题，我们需要在接收完数字后，再进行一次接收字符串：sacnner.nextLine();

用Scanner读取文件

• File file=new File(“d;/tiku.txt”);
• Scanner scanner=new Scanner(file);

需要抛出一个异常

Scanner中读取文件的方法：

• scanner.hasNext();检测下一行有没有内容
• scanner.nextLine();打印下一行的内容

剪切板Clipboard

调用剪切板的方法：

• Clipboard clipboard=Toolkit.getDefaultToolkit().getSystemClipboard();调用剪切板

• StringSelection selection=new StringSelection(“6666”);把想要让剪切板复制的话写进引号内

• clipboard.setContents(selection,null);把写出的话放进剪切板，set是设置，contents是内容

注：这三行的作用就是复制即ctrl+c的作用，用代码来完成复制

• Transferable transferable=clipboard.getContents(null);拿到剪切板里的内容 Get是得到， Contents是内容
• String search=(String) transferable.getTransferData(DataFlavor.stringFlavor);需要进行强制类型转换，并处理报错，因为剪切板可以复制很多类型的内容，比如图片，字符串，文件等等，所以需要设置拿到的是字符串格式。

注：这两步加起来才是拿到字符串的内容

• 上面两行是复制内容，下面两行是把内容取出来

转义字符

内存分配

如：常用类中 int a=5;

​ **引用类型中 Scanner scanner=new Scanner(); **

​ int[] c=new int[5];

• 栈内存

  • Int a 会放在栈内存里
  • Scanner scanner= 会放在栈内存
  • int[] 会放在栈内存

• 堆内存

  • new Scanner() 会放在堆内存
  • new int[5] 会放在堆内存

• 常量池（方法区）

  • 5会放在常量池内

创建对象时：分为三部分：

• 分配空间
• 对象初始化
• 分配地址

面向对象（思想）

权限修饰：

• public: 公开的，所有不同的包，不同的类全都可以访问得到。
• private: 私有的，只有自己的类（同一个class）中可以访问，其他的都访问不到。
• protected: 受保护的，除了不同包的其他类访问不到，其他都可以访问到，不同包的子类也可以 访问的到。
• 默认：只有同一个包中的类可以访问到，不同包访问不到。

封装：

• 实际含义是：该隐藏的隐藏，该暴露的暴露

• 全局变量：定义在类中的，所有方法都可以访问到，叫全局变量

• 局部变量：定义在一个方法里的，只有本方法可以访问的叫局部变量

定义变量：

​ 权限修饰符（public) + 类型（void、int、string、array[]…） + 变量名称

注：变量名称要用合法的JAVA标识符，首单词的第一个字母小写，后面的每一个单词首字母大写

方法封装：

• -定义格式： 修饰符（private) + 返回值类型（void、int、string…） + 方法名（自定义）+

（ 参数类型 参数名称 + , + 参数类型 参数名称） + { 代码体 + return 表达式 }

• 形式参数：在参数名称中，方法本身起的名字叫形式参数，只起一个代号的作用。

• 实际参数：在通过 . 调用方法时，依据形式参数传进的东西是实际参数。

• 不需要new对象就可以访问的方法封装：

  ​ public static Person getPerson(){

​ return new Person();

​ }

• 方法封装的好处：1.方便维护 2.减少冗余代码的出现

构造方法：

• 作用：用于该类的实例对象的初始化

• 格式： public Person(){ }

• 示例： pubilc int size;

  ​ pubilec Person(){

  ​ size=18;

  ​ }

  • 这就是给对象做了初始化，只要在另一个类中调用了Person的方法，new出了Person，那么当输出size是，默认输出18.
  • 构造方法中也可以传参数，当传入了参数后，再调用此方法是就必须传进参数对应的类型，如果想既可以传参数，也可以不传参数，那么就再构造一个同名的方法，该方法不加任何参数，这就叫构造方法的重载

This关键字

• this关键字总是指向该方法的对象。

  • 当this出现在构造方法中，this指的是该构造器正在初始化的对象，（也就是最外层的）
  • 在普通方法中引用，this指的是调用该方法的对象

• 作用：this关键字最大的作用就是让类中一个方法，访问该类里的另一个方法或Field

通过set方法对对象进行初始化：

代码： public void setSex(String sex){

​ this.sex=sex;

​ }

小结：

• 变量—————— 类对应的属性
• 构造方法——————new对象的时候对对象初始化
• 方法（函数）——————功能性的方法

封装打包学生类的代码：

Demo demo=new Demo();

Student student=new Student(“tom”,18,6,“3333”,“男”);

demo.save(student);

public void save(Student student){

​ System.out.println(student.getName());

​ System.out.println(student.getAge());

}

匿名对象

如上：Demo demo=new Demo();

​ demo.save(new Student());

• new Student只用到一次，没有给他起名字，这就是匿名对象

值传递

• JAVA的参数传递方式只有一种，那就是值传递

• 值传递含义：就是将实际参数的复制品传进方法，也就是重新创建一个一模一样的参数，对这个复制品进行方法操作，而实际参数的本身并没有受到影响。

  如：int a=5,b=5;

  ​ public void change(int a, int b){
  ​ a=100;

  ​ b=100;

  ​ }

  在此次方法操作中,a和b的值依旧是5，并没有变成100，就是对a与b的复制品进行了操作，实际参数本身没有改变

  如果想要将ab变成100的话，就需要返回a与b，在后面加return ,并将void改为Int

• 只有基本类型的值传递才是将复制品传进方法，其他类型的值传递是传进地址值的复制品，所以是可以对实际参数进行修改的

重载

• 方法名不可以重名，但是方法名相同时，参数列表不同时，如：方法一有两个参数，方法二有三个参数，尽管两个方法名字相同，但是可以同时存在，这叫方法的重载

• 重载只与方法名和参数名称有关，与权限修饰符，返回值类型等无关

• 方法名相同，参数名称不同或参数数量不同时，才叫重载

递归

• 含义：自己调用自己

• 斐波那契数列：

  • 1 1 2 3 5 8 13 21 34

  • 假设要求第n位的值：

    public int fb(int n){

    ​ if(n1 || n2){

    ​ return 1;

    ​ }else{

    ​ return fb(n-1)+fb(n-2);

    ​ }

    }

Static

• 特点：

  • static是跟随类的出现而出现，类名出现一次，那么static后面的内容就会执行一次
  • 被类的所有对象（new一次就是一个对象）共享：在调用static修饰的变量时，不同对象调用的是同一个变量，对象一对变量b进行改变时，对象二中的变量b也会改变而不同的对象调用不被static修饰的变量时，不同的对象使用的是不同的变量，对象一修改变量a时，对象二的变量a是不会被改变的
  • 可以通过类名直接调用

• 注意事项

  • 在静态方法中不可以使用this关键字 因为this关键字总是指向该方法的对象，静态方法是随着类的出现而出现，不需要New出对象，所以在静态方法中，没有对象是无法使用this的
  • 静态方法里不能访问成员变量或成员方法 因为静态方法是随着类的出现而出现，成员变量需要先New出对象，才能访问得到

• 静态变量和成员变量的区别

  • 所属不同
    • 静态变量属于类，所以也称为为类变量
      成员变量属于对象，所以也称为实例变量(对象变量)
      • 内存中位置不同
        静态变量存储于方法区的静态区
        成员变量存储于堆内存
        • 内存出现时间不同
          静态变量随着类的加载而加载，随着类的消失而消失
          成员变量随着对象的创建而存在，随着对象的消失而消失
          • 调用不同
            静态变量可以通过类名调用，也可以通过对象调用

• 用武之地

  • 使用工具方法时，可以加static，因为每次使用工具都需要New出对象，过于麻烦，而加上static后，只需要使用类的名字直接用点就可以调用，不需要new对象
  • 只需加载或执行一次

代码块：

• 局部代码块：

  • 出现在方法的内部，用大括号括起来的就是局部代码块
  • 定义在局部代码块内的变量，出了局部代码块后，外面的访问不到
  • 限定变量生命周期，及早释放，提高内存利用率

• 构造代码块

  • **在类中方法外出现；**多个构造方法中相同的代码存放到一起，每次调用构造都执行时就可以用构造代码块，并且在构造方法前执行

• 静态代码块

  • 在构造代码块前加上static，构造代码块是New一次，代码块的内容出现一次，静态代码块是类出现一次，就执行一次

集合框架

集合和数组的区别：

• 长度

  • 数组的长度固定
  • 集合长度可变

• 内容

  • 数组存储同一类型元素
  • 集合存储不同类型元素

• 元素类型

  • 数组可以存基本类型，可以存引用类型
  • 集合只可以存引用类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cwAr0zOK-1626426859712)(C:\Users\zz\AppData\Roaming\Typora\typora-user-images\image-20210713105709954.png)]

Collection

• 是一个接口并不是一个类，所以不可以被实例化。
• collection也可以有多态，可以通过Collection类型new出一个实例，如Collection collection=new ArrayList();

注：当传进的参数类型是Object时，代表可以传任何类型的参数，因为Object是所有类型的父类

• collection是自动补全toString方法，是可以直接打印出元素的，而数组直接打印的话是打印地址

• 方法：

  • 1：添加功能
    boolean add(Object obj):添加一个元素
    boolean addAll(Collection c):添加一个集合的元素

  • 2:删除功能
    void clear():移除所有元素
    boolean remove(Object o):移除一个元素
    boolean removeAll(Collection c):移除一个集合的元素

  • 3:判断功能
    boolean contains(Object o)：判断集合中是否包含指定的元素
    boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素
    boolean isEmpty()：判断集合是否为空

  • 5:长度功能
    int size():元素的个数

• 6:交集功能
  boolean retainAll(Collection c):两个集合都有的元素

  collection.retainAll(c2);

  这个功能意思是 把c2和collection的交集重新赋值给了collection，返回值类型的布尔值代表collection是否被改变过

• 7：把集合转换为数组
  String[] array=(String[]) collection.toArray();

  数组转集合：Arrays.asList(array);

4:获取功能

• Iterator iterator()(重点)

Iterator iterator=collection.iterator(); （代表获得当前集合的迭代器）

while(iterator.hasnext()){

System.out.println(iterator.next());

}

越界报错：

• 注：该过程中需要注意，多输出一个iterato,next(),表示找的是下一个元素

  • 注意的报错：NoSuchElementException与数组的越界报错一样，都表示访问的东西不存在

  • Student s1 = new Student();
    s1.setname("Tom");
    s1.setage(18);
    Student s2 = new Student();
    s2.setname("jack");
    s2.setage(20);
    collection.add(s1);
    collection.add(s2);
    Iterator iterator=collection.iterator();
    while(iterator.hasNext()){
    		System.out.println(((Student)iterator.next()).getname());
    		System.out.println(((Student)iterator.next()).getAge());
    		}
    

    注：上面的代码中，第一行打印的是Tom的名字，第二行打印的是Jack的年龄，因为使用了两次hasNext(); 第二个hasNext();找的是第二个元素Jack，所以打印了Jack的年龄

迭代器的遍历方法：

• 使用for循环使用迭代器遍历集合：

  • for(;iterator.hasnext()😉{
    System.out.println();

    }

List

• List是Collection接口的一个子接口。

• List是一个有序的集合，允许重复的元素存在

方法：

• List继承Collection，所以Collection有的方法，List也有

  • void add(int index,Object element):在指定位置添加元素

• List可以通过Get方法，利用下标获得元素，而collection没有Get方法，所以只能通过迭代器获得元素

• List也有迭代器

  • iterator.nextIndex(); 返回下一个索引
  • interator,previousIndex(); 返回上一个索引
  • interator.hasPervious(); 有没有前一个元素

ListIterator iterator=list.listIterator();
while(iterator.hasNext()){
   System.out.println(iterator.next());
}

• 删除功能，根据索引删除元素，返回的是被删除的元素

• System.out.println(list.remove(1));

• 修改功能，根据索引修改元素，返回被修改的原来的值

  • System.out.println(list,set(2,“mmm”));

    把下标为2的元素bbb修改为mmm，则返回bbb。

ArrayList：

• ArrayList的底层是数组，特点是查询快，增删慢
• 线程不安全，效率高。

Vector:

• 底层数据结构是数组，查询快，增删慢。
• 线程安全，效率低。

LinkList：

• LinkList的底层是链表，特点是查询慢，增删块

• 线程不安全，效率高。

• 注：链表没有下标

• 方法：

  • LinkedList list=new LinkedList();

    list.addFirst(); （在第一位添加元素）

    list.addLast(); （在最后一位添加元素）

    list.getFirst(); （获得第一位）

    list.indexOf(); （获得元素的索引）

    list.lastIndexOf(); （获得最后的索引位置）

    list.removeFirst(); （移除第一个）

注：

容器指集合

ConcurrentModificationException

• 含义：并发修改异常

  • 并发： 同一时刻有多个任务同时操作这个数据

• 该报错会在迭代器里出现

  • 假如List中有三个元素，删除第三个元素，就会并发修改异常报错
  • 因为，迭代器是根据原本有三个元素的List拿到的，本身是准备遍历三个元素的，但是中途删除了一个元素，两边数据不一致，同时更改了一个数据，所以才是并发修改异常

ListIterator iterator=list.listIterator();
while(iterator.hasNext()){
	System.out.println(iterator.next());
	list.remove(2);
	}

数据结构：

数组：

• 定义：相同数据类型的元素按一定顺序排列的集合。

• 连续的存储空间 特点：查询快，但是增删慢

  • 如果需要增加或删除的话，就是重新开辟空间，创建另一个数组，把原本的填上去再加上需要增加的元素，删除反之
  • 时间复杂度：O(1)

链表：

• 链表中每个元素都是一个对象，每个对象称为一个节点，包含有数据域key和指向下一节点的指针next，通过各个节点间的相互连接，最终串联成一个链表

• 不是连续的存储空间，用箭头一个一个指向下一个元素 特点：查询慢，增删块

  • 时间复杂度：O(n)

队列：

• 含义：程序运行多个任务，但是一次处理不过来，把所有的任务依次放进队列，一个一个去取

• 特点：先进先出

栈：

• 定义：限定仅在表尾进行插入和删除操作的线性表

• 含义：好像进电梯，入口和出口是同一个，先进来的排在最后面，最后进来的排在最前面

• 特点：后进先出，先进后出

树：

• 定义：树是n(n>=0)个结点的有限集。n=0时称为空树。在任意一颗非空树中：

  • 有且仅有一个特定的，称为根的结点
  • 当n>1时，其余结点可分为m（m>0）个互不相交的有限集t1、t2、…tm，其中每一个集合本身又是一颗树，并且称为根的子树。

• 表示人物职称或者级别时，用树状图

• 二叉树：一个元素只能分两个叉

  • 左边的放小的，右边的放大的
  • 如果从左往右数，那么就是依次从小到大排列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wlgwNWtI-1626426859712)(D:\笔记图片\二叉树.png)]

堆：

• 含义：堆是具有下列性质的完全二叉树：
  • 每个结点的值都大于或等于其左右孩子的结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。

图：

• 表示人物关系
• JAVA的垃圾自动回收就是图的应用，如果某个对象正在被其他对象用着，那么就不是垃圾。如果某个对象失效，或者内容为null，那么图中的连线或者节点就会消失，JAVA判定为垃圾

时间复杂度

• O(1) 表示需要查找一次就可以找到需要查找的元素
• O(n) 表示要查找第几个，就需要查找第几次，查找第N个，就需要查找第N次

封装业务层：MVC三层架构

M：model（模型），指实体类

V：view（视图），能看到的所有东西就是视图

C：controller（终端控制器）

前端的任何请求，都要转到后台的代码控制器，控制器拿到数据后，再交给业务层的方法，做业务处理，业务层拿到东西后再去调动数据库

• 控制层： 接收或者返回数据
• 服务层：做具体的业务处理
• 数据库层：做增删改查操作

例如：普通的代码页面中的命令行就是视图，然后选择的1.2.3接收给控制层，控制层接收数据给服务层，服务层拿到数据做具体的业务处理，服务层接收用户的输入，然后把他封装成一个对象，再传给数据库，数据库做增删改查。

JDBC

• 全称： java database connection

配置四大参数，用于获得mysql链接

• 用户名、密码
• url（地址）（指链接谁、链接哪个IP下，哪个端口下的哪个数据库）
• 驱动

//加载驱动
Class.forName("com.mysql.jdbc.Driver")   //引号内为驱动名称
//填写url，用户名，密码获得链接
Connection connection= DriveManager.getConnection("jdbc:mysql://127.0.0.1:3306/库名?useUnicode=true&characterEncoding=utf-8","root","root123")         //如果connection没有打印null打印出地址，表示链接成功

注：乱码时，在填写url时加上 ?useUnicode=true&characterEncoding=utf-8

增删改查的语句

• 构造sql语句
• 获得执行sql的对象（根据connection获得statement）
• 往sql里赋值
• 执行

String sql="insert into book_table(book_name,book_author,book_price) values(?,?,?)";                  //定义sql语句
PreparedStatement statement=(PreparedStatement)connection.prepareStatement(sql);
statement.setString(1,"三国");
statement.setString(2,"某某某");
statement.setLong(3,500);         //数字表示第几个问号
statement.executeUpdate();          //执行更新操作
//int result=statement.executeUpdate();     返回数字表示影响了几行

注：直接使用Statement对象执行sql语句,拼接字符串时，会有sql注入攻击的安全隐患

如：select*from user_table where user_name=‘tom’ and user_pwd=‘456’ or 1=1;

• 删除

String sql="delete from book_table where book_id=?";
	PreparedStatement statement=(PreparedStatement) connection.prepareStatement(sql);
	statement.setLong(1, 9);
	int resulet=statement.executeUpdate();
	System.out.println(resulet);

• 更改

  String sql="update book_table set book_name=? where book_id=?";
  	PreparedStatement  statement=(PreparedStatement) connection.prepareStatement(sql);
  	statement.setString(1, "ooo");
  	statement.setLong(2, 8);
  	int resulet=statement.executeUpdate();
  	System.out.println(resulet);