一、java基础

1.1 java关键字

image.png

1.2 标识符

image.png

二、数据类型（八大基本数据类型）

image.png

2.1 什么是字节

image.png

  1. package day1;
  3. public class demo1 {
  4.     public static void main(String[] args) {
  6. //        八大基本数据类型
  7.         int age =22;
  8.         long ll = 222232323232L;
  9.         short sht ='a';
  10. //        String name= "阿飞";
  11.         float scope = 22.2F;
  12.         double saly = 22.1;
  13.         boolean isTrue = true;
  14.         char chs = 'A';
  15.         byte b = 123;
  17.     }
  18. }

2.2 类型转换

image.png

2.3 变量

image.png
image.png

2.4 常量

image.png

三、 基本运算符

image.png

image.png

六、流程控制

6.1 scanner对象

image.png
image.png

  1. package day1;
  3. import java.util.Scanner;
  5. public class ScannerTest {
  6.     public static void main(String[] args) {
  7. //获取用户键盘的输入
  8.         Scanner scanner = new Scanner(System.in);
  9. //        拿到用户输入的数据
  10.         String str =scanner.nextLine();
  11.         System.out.println(str);
  12. //        关闭输入流
  13.         scanner.close();
  14.     }
  15. }

6.2 scanner进阶(计算数字之和)

  1. package day1;
  3. import java.util.Scanner;
  5. public class ScannerT {
  6.     public static void main(String[] args) {
  8.         Scanner scanner = new Scanner(System.in);
  9.         int sum = 0;
  10.         int num = 0;
  11. //        计算树数字之和
  12. //        判断用户是不是数字，如果不是返回结果
  13.         while (scanner.hasNextInt()){
  14.             int userin = scanner.nextInt();
  15.             num+=userin;
  16.             sum++;
  17.         }
  18.         System.out.println(sum);
  19.         System.out.println(num);
  21.     }
  22. }

6.3 顺序结构

image.png

6.4 if单选择结构

image.png

6.5 switch多选择结构

image.png

6.6 while循环

image.png

6.7 do while循环

image.png

6.8 for循环（重点）

image.png

  • 九九乘法表 ```java package day1;

public class Fortest { public static void main(String[] args) {

  1.     for (int j = 1; j <= 9; j++) {
  3.         for (int i = 1; i <= j; i++) {
  4.             System.out.print(i + "*" + j + "=" + (j * i)+"\t");
  6.         }
  7.         System.out.println();
  8.     }
  9. }

}

  1. <a name="gNHyu"></a>
  2. #### 6.9 增强for循环
  3. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618043481697-cbc1af06-8d0a-49b7-a9ce-8f9ddda9ec52.png#align=left&display=inline&height=538&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1076&originWidth=2280&size=784325&status=done&style=none&width=1140)
  4. <a name="efFTd"></a>
  5. #### 6.10 break    continue
  6. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618043781270-37ccd461-f157-4e14-b6c9-8181aff928ec.png#align=left&display=inline&height=541&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1082&originWidth=1880&size=1598099&status=done&style=none&width=940)
  7. <a name="WSUwA"></a>
  8. ### 七、方法
  9. <a name="EexD2"></a>
  10. #### 7.1 什么是方法
  11. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618052223665-231195c7-562a-4e2b-a3fd-16ef5869b47c.png#align=left&display=inline&height=404&margin=%5Bobject%20Object%5D&name=image.png&originHeight=808&originWidth=2218&size=654736&status=done&style=none&width=1109)
  12. <a name="yVBPl"></a>
  13. #### 7.2 方法的定义
  14. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618052278637-0157fbfd-4019-4e28-bcf7-e54b70ad8ce3.png#align=left&display=inline&height=606&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1212&originWidth=2420&size=1445076&status=done&style=none&width=1210)
  15. <a name="VLhLM"></a>
  16. #### 7.3 方法的调用
  17. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618052769155-eecc31f7-bb36-419a-ba99-4bfcb46a3b8e.png#align=left&display=inline&height=436&margin=%5Bobject%20Object%5D&name=image.png&originHeight=872&originWidth=1302&size=676459&status=done&style=none&width=651)
  18. <a name="yJbO2"></a>
  19. #### 7.4 方法的重载
  20. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618116870884-0f9c8e3e-b6bc-4891-9c45-8fd11ae89a47.png#align=left&display=inline&height=520&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1040&originWidth=2266&size=666606&status=done&style=none&width=1133)
  21. <a name="YMyhh"></a>
  22. #### 7.5 命令行传参
  23. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618117161150-8ecd9237-ffa7-4429-bb9a-d14572e104b9.png#align=left&display=inline&height=464&margin=%5Bobject%20Object%5D&name=image.png&originHeight=928&originWidth=2168&size=641844&status=done&style=none&width=1084)
  24. <a name="o6Q5l"></a>
  25. #### 7.6 可变参数
  26. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618117485782-41573eb1-89e9-4987-88ce-91d782272565.png#align=left&display=inline&height=544&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1088&originWidth=2238&size=811759&status=done&style=none&width=1119)
  27. ```java
  28. package day1;
  30. public class demo03 {
  31.     public static void main(String[] args) {
  32.         test(1, 3, 4, 5, 56, 6);
  33.     }
  35.     /**
  36.      * @不定长参数
  37.      */
  38.     public static void test(int... i) {
  39.         for (int j = 0; j < i.length; j++) {
  40.             System.out.println(i[j]);
  41.         }
  43.     }
  44. }

7.7 递归

image.png

  1. package day1;
  3. public class demo3 {
  4.     public static void main(String[] args) {
  5.         System.out.println(test(1));
  6.     }
  7. //测试递归，求阶乘
  8.     public static int test(int n){
  9.         if (n==1){
  10.             return 1;
  11.         }else {
  12.             return n*test(n-1);
  13.         }
  15.     }
  16. }

八、数组

8.1 数组的定义

image.png

8.2 数组声明创建

image.png

8.3 数组的三种初始化

image.png

8.4 数组的四个基本特点

image.png

8.5 数组边界

image.png

8.6 多维数组

image.png

  1. package day1;
  3. public class demo4 {
  4.     public static void main(String[] args) {
  5. //        多维数组
  6. //      遍历多维数组的值
  7.         int[][] arr= {{1,3},{2,34,5},{4,3}};
  8.         for (int i = 0; i < arr.length; i++) {
  9.             for (int j = 0; j <arr[i].length ; j++) {
  10.                 System.out.println(arr[i][j]);
  11.             }
  12.         }
  14.     }
  15. }

8.7 Arrays类详解

image.png

九、面向对象

9.1 思想

image.png

9.2 什么是面向对象

image.png9.3 类和对象的关系

image.png

9.4 构造器详解

image.png

  1. package demo2;
  3. public class Person {
  4.     String name;
  5.     int age;
  6. //    默认无参构造器，如果有有参，无参构造器就会消失，需要手动定义
  8.     public Person(){
  10.     }
  12.     public Person(String name, int age) {
  13.         this.name = name;
  14.         this.age = age;
  15.     }
  16. }

9.5 对象内存分析

image.png

9.6 封装

image.png

  1. package demo2;
  3. public class Person {
  4.     private String name;
  5.     private int age;
  6. //    默认无参构造器，如果有有参，无参构造器就会消失，需要手动定义
  8.     public Person(){
  10.     }
  12.     public Person(String name, int age) {
  13.         this.name = name;
  14.         this.age = age;
  15.     }
  17.     public void setName(String name){
  18.        this.name =name;
  20.     }
  22.     public String getName() {
  23.         return name;
  24.     }
  26.     public int getAge() {
  27.         return age;
  28.     }
  30.     public void setAge(int age) {
  31.         this.age = age;
  32.     }
  33. }

9.7 继承

image.png

9.8 super

image.png

9.9 重写

image.png

9.10 多态

image.png
image.png

  1. package demo3;
  3. public class Test {
  4.     public static void main(String[] args) {
  5.         Student s1 = new Student();
  6.         Person s2 = new Student();
  7.         s1.eat();
  8.     }
  9. }

9.11 instance 引用类型转换

  • 可以通过instance来判断2个类是否存在父子关系

image.png

  1. package demo3;
  3. public class Test {
  4.     public static void main(String[] args) {
  5. //        低转高自动转型
  6. //        Student s1 = new Student();
  7. //        Person person = s1;
  8. //        高转低强制转换
  10.         Person person = new Student();
  12.         Student s1 = (Student) person;
  13.         s1.say();
  15.     }
  16. }

9.12 抽象类

image.png

抽象类注意事项：

  • 不能new这个抽象类，只能靠子类去实现它：约束！
  • 抽象类中可以写普通方法
  • 抽象方法必须在抽象类中
  • 抽象类有无参构造器

案例：

  1. 定义一个抽象类Person，里面有个抽象方法doSomeThing ```java package demo04;

public abstract class Person { // public abstract void doSomeThing(); }

  2. 2. 定义一个Student类继承Person，需要重写里面的所有方法
  3. ```java
  4. package demo04;
  6. public class Student extends Person{
  7.     @Override
  8.     public void doSomeThing() {
  9.         System.out.println(5555);
  10.     }
  11. }

9.13 接口的定义与实现

image.png

接口的注意事项：

  • 约束
  • 定义一些方法，让不同的人去实现~10>1
  • 里面方法必须是抽象方法 public abstract
  • 里面的属性都是静态常量 public static final
  • 结构不能对实例化，结构没有构造方法
  • 实现implements可以实现多个接口
  • 必须重写接口中的方法

案例：

  1. 定义2个接口分别是PersonService和UserService，里面分别有鸽子的抽象方法 ```java package demo05;

public interface PersonService { void edit(); }

  1. ```java
  2. package demo05;
  4. public interface UserService {
  6. //    里面的属性都是静态常量 public static final
  7.     static final  int NUM = 0;
  9. //    里面的方法 都是 public abstract 可以省略 没有方法体,可以有参数
  10.     void add(String name);
  11.     void delete(String name);
  12.     void change(String name);
  13.     void select(String name);
  14. }

  1. 定义一个实现类来实现PersonService和UserService，并且重写他们的全部方法 ```java package demo05; //必须重写接口所有的方法 public class UserServiceImpl implements UserService,PersonService {

    @Override public void add(String name) {

    }

    @Override public void delete(String name) {

    }

    @Override public void change(String name) {

    }

    @Override public void select(String name) {

    }

    @Override public void edit() {

    } }

  1. <a name="0VMMf"></a>
  2. #### 9.14 异常
  4. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618279751470-235a0d0d-b715-419e-82f4-cf78e6fbe1b1.png#align=left&display=inline&height=363&margin=%5Bobject%20Object%5D&name=image.png&originHeight=884&originWidth=2230&size=923679&status=done&style=none&width=916)
  5. <a name="eAR0Q"></a>
  6. #### 9.15 异常-体系架构
  7. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618280109612-5e34022c-dba5-4e38-b0dd-7c1b416da06a.png#align=left&display=inline&height=573&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1146&originWidth=1902&size=690551&status=done&style=none&width=951)
  8. <a name="ys71C"></a>
  9. #### 9.16 异常-ERROR
  10. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618280339667-42bad6b7-d59b-45e8-a7ed-8ef4d027f06d.png#align=left&display=inline&height=403&margin=%5Bobject%20Object%5D&name=image.png&originHeight=806&originWidth=2344&size=763306&status=done&style=none&width=1172)
  11. <a name="bcjyF"></a>
  12. #### 9.17 异常-Exception
  13. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618280379621-4b6ba20c-6d25-4fe0-8061-5a401b23659c.png#align=left&display=inline&height=578&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1156&originWidth=2276&size=1057996&status=done&style=none&width=1138)
  14. <a name="AypgI"></a>
  15. #### 9.18 异常-捕获-抛出
  16. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618280619542-8943601f-c01e-48dc-89dc-13fd44597317.png#align=left&display=inline&height=315&margin=%5Bobject%20Object%5D&name=image.png&originHeight=630&originWidth=1024&size=172975&status=done&style=none&width=512)
  17. ```java
  18. package demo6;
  20. public class TestException {
  21.     public static void main(String[] args) {
  23.         int a=1;
  24.         int b=0;
  26. //        调用异常的方法需要接收异常
  27.         try {
  28.             new TestException().test(1, 3);
  29.         } catch (Exception e) {
  30.             e.printStackTrace();
  31.         } finally {
  32.         }
  35.         try{
  36. //        可能出现异常的代码
  37.         System.out.println(a/b);
  38.     }catch (ArithmeticException e){
  39. //        定义多个异常，异常等级从小到大
  40.         System.out.println("捕获到异常了ArithmeticException");
  42.     }catch (Exception e){
  43.         System.out.println("捕获到异常了ArithmeticExceptionException");
  44.     }catch (Throwable e){
  45.         System.out.println("捕获到异常了Throwable");
  46.     }
  47.     finally {
  48.         System.out.println("无论什么情况都会执行");
  49.     }
  51.     }
  52. // 抛出异常的方法
  53.     public void test(int a,int b)throws Exception{
  54. //        在方法中定义异常
  55.         throw new ArithmeticException();
  57.     }
  58. }

9.19 异常-自定义异常

image.png

9.19 异常总结image.png

9.20 基本包装类型

image.png

9.21 integer类的概述和使用

image.png

9.21 包装类-int和String 的相互转换

image.png

9.22 包装类-自动装箱和拆箱

image.png

十、集合

10.1 集合类体系结构

  • LIST可重复（单列)
  • SET不可重复（单列)
  • image.png

    10.2 Collection的创建和使用

    ```java package demo7;

import java.util.ArrayList; import java.util.Collection;

public class TestConnection { public static void main(String[] args) {

  1.     Collection<String> c1 = new ArrayList<>();
  2.     c1.add("你好我是collection");
  3.     c1.add("你好我是collection");
  4.     c1.add("你好我是collection");
  5.     System.out.println(c1);
  6. }

}

  1. <a name="pcCco"></a>
  2. #### 10.3 Collection的常用方法
  3. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/298474/1618301234264-68a926fd-8517-4be2-859e-15dc100d621c.png#align=left&display=inline&height=397&margin=%5Bobject%20Object%5D&name=image.png&originHeight=794&originWidth=1682&size=465150&status=done&style=none&width=841)
  4. <a name="MeaZW"></a>
  5. #### 10.4 Collection集合的遍历
  6. ```java
  7. package demo7;
  9. import java.util.ArrayList;
  10. import java.util.Collection;
  11. import java.util.Iterator;
  13. public class TestConnection {
  14.     public static void main(String[] args) {
  16.         Collection<String> c1 = new ArrayList<>();
  17.         c1.add("你好我是collection1");
  18.         c1.add("你好我是collection2");
  19.         c1.add("你好我是collection3");
  21. //        使用    iterator()
  22. //      返回此集合中的元素的迭代器
  23.         Iterator<String> iterator = c1.iterator();
  25. //        hasNext()
  26. //      如果迭代具有更多元素，则返回 true 。
  27. //        使用迭代器遍历里面的元素
  29. //            next()
  30. //      返回迭代中的下一个元素。
  32.         while (iterator.hasNext()) {
  33.             //            next()
  34. //      返回迭代中的下一个元素。
  35.             String str = iterator.next();
  36.             System.out.println(str);
  37.         }
  38.     }
  39. }

10.5 Collection集合的使用步骤

image.png

10.6 Collection使用学生对象来存储

  1. 定义一个学生类，里面有2个属性，并且有有参无参构造器和get，set方法 ```java package demo7;

public class Student { private String name; private int age;

  1. public Student() {
  2. }
  4. public Student(String name, int age) {
  5.     this.name = name;
  6.     this.age = age;
  7. }
  9. public String getName() {
  10.     return name;
  11. }
  13. public void setName(String name) {
  14.     this.name = name;
  15. }
  17. public int getAge() {
  18.     return age;
  19. }
  21. public void setAge(int age) {
  22.     this.age = age;
  23. }

}

  2. 2. 主方法
  3. ```java
  4. package demo7;
  6. import java.util.ArrayList;
  7. import java.util.Collection;
  8. import java.util.Iterator;
  10. public class TestCollection {
  11.     public static void main(String[] args) {
  12. //定义一个Student类的集合
  13.         Collection<Student> coll = new ArrayList<>();
  14. //        定义三个学生
  15.         Student s1 = new Student("周杰伦", 12);
  16.         Student s2 = new Student("林俊杰", 15);
  17.         Student s3 = new Student("蔡徐坤", 16);
  18. //将三个学生添加到集合
  19.         coll.add(s1);
  20.         coll.add(s2);
  21.         coll.add(s3);
  23. //        拿到集合的可迭代对象
  25.         Iterator<Student> iterator = coll.iterator();
  26. //       遍历可迭代对象
  27.         while (iterator.hasNext()){
  28.             Student next = iterator.next();
  29.             System.out.println(next.getName()+next.getAge());
  31.         }
  34.     }
  35. }

10.7 List集合的概述和特点

image.png

  1. package demo7;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. public class TestList {
  8.     public static void main(String[] args) {
  10. //    有序列表可重复
  11.         List<String> list=new ArrayList<>();
  12.         list.add("张飞");
  13.         list.add("关羽");
  14.         list.add("张飞");
  16.         Iterator<String> iterator = list.iterator();
  17.         while (iterator.hasNext()){
  18.             String next = iterator.next();
  19.             System.out.println(next);
  20.         }
  21.     }
  22. }

10.8 List的特殊方法

  • 遍历List的列表最使用 for > list.size()

image.png

  1. package demo7;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. public class TestList {
  8.     public static void main(String[] args) {
  10. //    有序列表可重复
  11.         List<String> list=new ArrayList<>();
  12.         list.add("张飞");
  13.         list.add("关羽");
  14.         list.add("张飞");
  16. //        Iterator<String> iterator = list.iterator();
  17. //        while (iterator.hasNext()){
  18. //            String next = iterator.next();
  19. //            System.out.println(next);
  20. //
  21. //
  22. //        }
  23. //        新增元素在下标1
  24. //        list.add(1,"苟福成");
  25. //        删除指定下标元素
  26. //        list.remove(2);
  27. //        System.out.println(list);
  28. //     修改指定下标元素
  29. //        list.set(1,"草上飞");
  30. //        System.out.println(list);
  31. //      根据指定下表返回元素
  32. //        String s = list.get(1);
  33. //        System.out.println(s);
  34. //        遍历List可以使用get配合list.size()
  35.         for (int i = 0; i <list.size(); i++) {
  36.             System.out.println(list.get(i));
  37.         }
  38.     }
  39. }

10.10 列表迭代器

image.png

10.11 增强for循环

image.png

10.12 List的三种遍历方式

  1. package demo7;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.Iterator;
  6. import java.util.List;
  8. public class TestThree {
  9.     public static void main(String[] args) {
  10.         List<Student> coll = new ArrayList<Student>();
  11. //        定义三个学生
  12.         Student s1 = new Student("周杰伦", 12);
  13.         Student s2 = new Student("林俊杰", 15);
  14.         Student s3 = new Student("蔡徐坤", 16);
  15.         coll.add(s1);
  16.         coll.add(s2);
  17.         coll.add(s3);
  18. //        使用迭代器遍历
  19.         Iterator<Student> iterator = coll.iterator();
  20.         while (iterator.hasNext()){
  21.             Student stu = iterator.next();
  22.             System.out.println(stu.getName());
  23.             System.out.println(stu.getAge());
  25.         }
  27.         System.out.println("=====================================");
  28. //        使用for 下标遍历
  30.         for (int i = 0; i < coll.size(); i++) {
  31.             System.out.println(coll.get(i).getName());
  32.             System.out.println(coll.get(i).getAge());
  35.         }
  36.         System.out.println("=====================================");
  38. //        使用增强for循环遍历
  39.         for (Student student : coll) {
  40.             System.out.println(student.getName());
  41.             System.out.println(student.getAge());
  43.         }
  44.     }
  45. }

10.13 常见数据结构之栈

image.png

10.14 常见数据结构之队列

image.png

10.13 常见数据结构之数组

image.png

10.14 常见数据结构之链表

image.png

10.15 List集合子类特点

image.pngl
练习：

  1. package demo7;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.LinkedList;
  7. public class TestLink {
  8.     public static void main(String[] args) {
  9. //        查询快增删慢
  10.         ArrayList<String> str = new ArrayList<>();
  11.        str.add("张飞");
  12.        str.add("刘备");
  13.        str.add("关羽");
  14.         System.out.println("====================================");
  15. // 迭代器遍历
  16.         Iterator<String> striter = str.iterator();
  17.         while (striter.hasNext()){
  18.             String next = striter.next();
  19.             System.out.println(next);
  21.         }
  22.         System.out.println("====================================");
  24. //  索引下标遍历
  25.         for (int i = 0; i < str.size(); i++) {
  26.             String s = str.get(i);
  27.             System.out.println(s);
  29.         }
  31. //        增强for
  32.         for (String s : str) {
  33.             System.out.println(s);
  35.         }
  37.         System.out.println("====================================");
  38. //   linklist查询慢增删快
  40.         LinkedList<String> link = new LinkedList<>();
  41.         link.add("周杰伦1");
  42.         link.add("周杰伦2");
  43.         link.add("周杰伦3");
  44.         Iterator<String> linkiter = link.iterator();
  46. //        迭代器遍历
  47.         while(linkiter.hasNext()){
  48.             String next = linkiter.next();
  49.             System.out.println(next);
  50.         }
  51. //        索引下标遍历
  53.         for (int i = 0; i < link.size(); i++) {
  54.             String s = link.get(i);
  55.             System.out.println(s);
  57.         }
  58. //        增强for循环遍历
  59.         for (String s : link) {
  60.             System.out.println(s);
  62.         }
  64.     }
  65. }

10.16 LinkedList集合的特有功能

image.png

10.17 set集合概述和特点

image.png

  1. import java.util.HashSet;
  2. import java.util.Iterator;
  3. import java.util.Set;
  5. public class demo08 {
  6.     public static void main(String[] args) {
  7. //  不可重复，不按顺序，没有索引遍历
  9.         Set<String> strings = new HashSet<String>();
  10.         strings.add("张飞1");
  11.         strings.add("张飞2");
  12.         strings.add("张飞3");
  13.         strings.add("张飞4");
  14.         strings.add("张飞5");
  15.         strings.add("刘备");
  16.         strings.add("张飞1");
  19. //        迭代器遍历
  20.         Iterator<String> iterator = strings.iterator();
  21.         while (iterator.hasNext()){
  22.             String next = iterator.next();
  23.             System.out.println(next);
  24.         }
  25.         System.out.println("========================");
  26. //        增强for遍历
  27.         for (String string : strings) {
  28.             System.out.println(string);
  30.         }
  31.     }
  32. }

10.18 哈希值

image.png

  1. package demo08;
  3. public class TestHash {
  4.     public static void main(String[] args) {
  5.         System.out.println("你好".hashCode());//652829
  6.         System.out.println("中国".hashCode());//642672
  7.     }
  8. }

10.18 HashSet集合概述和特点

image.png

10.19 HashSet集合保证元素唯一性-源码解析

image.png

10.20 常见数据结构之哈希表

image.png
image.png

10.21 HashSet集合存储学生对象并遍历

image.png

需要重写Student类hascode 和equsal方法

  1. package demo08;
  3. import java.util.Objects;
  5. public class Student {
  6.     private String name;
  7.     private int age;
  10.     public Student() {
  11.     }
  13.     public Student(String name, int age) {
  14.         this.name = name;
  15.         this.age = age;
  16.     }
  18.     public String getName() {
  19.         return name;
  20.     }
  22.     public void setName(String name) {
  23.         this.name = name;
  24.     }
  26.     public int getAge() {
  27.         return age;
  28.     }
  30.     public void setAge(int age) {
  31.         this.age = age;
  32.     }
  33. //重写2个方法
  34.     @Override
  35.     public boolean equals(Object o) {
  36.         if (this == o) return true;
  37.         if (o == null || getClass() != o.getClass()) return false;
  38.         Student student = (Student) o;
  39.         return age == student.age && Objects.equals(name, student.name);
  40.     }
  42.     @Override
  43.     public int hashCode() {
  44.         return Objects.hash(name, age);
  45.     }
  46. }

主方法

  1. package demo08;
  3. import java.util.HashSet;
  5. public class TestHashSet {
  6.     public static void main(String[] args) {
  7. //不可重复，实现 姓名和 年龄相同 就算一个人，需要重新对象类的hashcode 和 equs方法
  8.         HashSet<Student> students = new HashSet<>();
  9.         Student student1 = new Student("张飞",21);
  10.         Student student2 = new Student("刘备",22);
  11.         Student student3 = new Student("关羽",23);
  12. // 重复的人员
  13.         Student student4 = new Student("关羽",23);
  15.         students.add(student1);
  16.         students.add(student2);
  17.         students.add(student3);
  18.         students.add(student4);
  20.         for (Student student : students) {
  21.             System.out.println(student.getName()+student.getAge());
  23.         }
  25.     }
  26. }

10.21 linkedHaset集合概述和特点

image.png
image.png

10.22 treeSet集合概述和特点

image.png

  1. package demo08;
  3. import java.util.TreeSet;
  5. public class TestTreeSet {
  6.     public static void main(String[] args) {
  7. //        注意这里要使用引用类型包装类
  8. //        不可重复切有序
  9.         TreeSet<Integer> integers = new TreeSet<>();
  10.         integers.add(1);
  11.         integers.add(22);
  12.         integers.add(15);
  13.         integers.add(30);
  14.         integers.add(15);
  16.         for (Integer integer : integers) {
  17.             System.out.println(integer);
  19.         }
  20.     }
  21. }

10.23 自然排序Comparable的使用

image.png

  • 主方法 ```java package demo08;

import java.util.TreeSet;

public class TestTreeSet { public static void main(String[] args) {

  1.     TreeSet<Student> treeSet = new TreeSet<Student>();
  3.     Student zhoujielun = new Student("zhoujielun", 22);
  4.     Student wangfei = new Student("wangfei", 32);
  5.     Student xiaofeifei = new Student("xiaofeifei", 12);
  6.     Student goufucheng = new Student("goufucheng", 52);
  8.     treeSet.add(zhoujielun);
  9.     treeSet.add(wangfei);
  10.     treeSet.add(xiaofeifei);
  11.     treeSet.add(goufucheng);
  13.     for (Student student : treeSet) {
  14.         System.out.println(student.getName()+":"+student.getAge());
  15.     }
  16. }

}

  2. - 泛型如果为类，那么这个类必须实现Comparable接口,并且重写compareTo方法
  3. ```java
  4. public class Student implements Comparable<Student> {
  5.   @Override
  6.     public int compareTo(Student o) {
  7.         return -1;
  8.     }
  9. }

返回值为 -1 > 1 分别代表： -1 ：对存储的数据倒着打印 0 ：只会存储一个元素 1：对存储的数据正着打印

  1. package demo08;
  3. import java.util.Objects;
  5. // 需要实现Comparable
  6. public class Student implements Comparable<Student> {
  7.     private String name;
  8.     private int age;
  11.     public Student() {
  12.     }
  14.     public Student(String name, int age) {
  15.         this.name = name;
  16.         this.age = age;
  17.     }
  19.     public String getName() {
  20.         return name;
  21.     }
  23.     public void setName(String name) {
  24.         this.name = name;
  25.     }
  27.     public int getAge() {
  28.         return age;
  29.     }
  31.     public void setAge(int age) {
  32.         this.age = age;
  33.     }
  34. //重写2个方法
  35.     @Override
  36.     public boolean equals(Object o) {
  37.         if (this == o) return true;
  38.         if (o == null || getClass() != o.getClass()) return false;
  39.         Student student = (Student) o;
  40.         return age == student.age && Objects.equals(name, student.name);
  41.     }
  43.     @Override
  44.     public int hashCode() {
  45.         return Objects.hash(name, age);
  46.     }
  48.     @Override
  49.     public int compareTo(Student o) {
  50. //        this 代表传入的  o代表上一个对像  2个进行对比
  51.         /**
  52.          * zhoujielun22-------->zhoujielun22
  53.          * wangfei32-------->zhoujielun22
  54.          * xiaofeifei12-------->zhoujielun22
  55.          * goufucheng52-------->zhoujielun22
  56.          * goufucheng52-------->wangfei32
  57.          * xiaofeifei:12
  58.          * zhoujielun:22
  59.          * wangfei:32
  60.          * goufucheng:52
  61.          */
  62.         int num = this.age - o.age; //此处根据年龄排序  规则是 数值越大就第最后一个输出
  63. //        int num = this.age - o.age;此处根据年龄倒叙
  64.         System.out.println(this.getName()+this.getAge()+"-------->"+o.getName()+o.getAge());
  65. //  年龄相同时按照字母排序 ，否则添加不上
  66.         int resutlt = num==0?this.name.compareTo(o.name):num;
  67.         System.out.println(resutlt);
  68.         return resutlt;
  69.     }
  70. }

10.21 比较器Comparable的使用

image.png

  1. package demo09;
  3. import java.util.Comparator;
  4. import java.util.HashSet;
  5. import java.util.TreeSet;
  7. public class TestHashset {
  8.     public static void main(String[] args) {
  11. //使用匿名内部类 可以省去实现 Comparator接口
  12.       TreeSet<Student> treeSet= new TreeSet<Student>(new Comparator<Student>() {
  13.            @Override
  14. //           重写 Comparator对比方法
  15.            public int compare(Student o1, Student o2) {
  16.                int num= o1.getAge()-o2.getAge();
  17.                int result = num==0?o1.getName().compareTo(o2.getName()):num;
  18.                return result;
  19.            }
  20.        });
  22.         Student zhoujielun = new Student("zhoujielun", 22);
  23.         Student wangfei = new Student("wangfei", 32);
  24.         Student xiaofeifei = new Student("xiaofeifei", 12);
  25.         Student goufucheng = new Student("goufucheng", 52);
  26.         Student helen = new Student("helen", 52);
  28.         treeSet.add(zhoujielun);
  29.         treeSet.add(wangfei);
  30.         treeSet.add(xiaofeifei);
  31.         treeSet.add(goufucheng);
  32.         treeSet.add(helen);
  34.         for (Student student : treeSet) {
  35.             System.out.println(student.getName()+":"+student.getAge());
  37.         }
  40.     }
  41. }

十一、泛型

11.1 泛型的概述

image.png

11.2 泛型类

  1. package demo09;
  3. import obj.Testconstor;
  5. //泛型类
  6. public class TestGeneric<T> {
  8.     private T t;
  10.     public T getT() {
  11.         return t;
  12.     }
  14.     public void setT(T t) {
  15.         this.t = t;
  16.     }
  17. }

11.3 泛型方法

  1. package demo09;
  3. import obj.Testconstor;
  5. //泛型方法
  6. public class TestGeneric {
  7.    public <T> void getN(T t){
  8.        System.out.println(t);
  10.    }
  11. }

11.4 泛型接口

  1. package demo10;
  3. public interface UserService<T> {
  4.     void add(T t);
  6. }
  9. ----实现接口
  11. package demo10;
  13. public class UserServiceImpl<T> implements UserService<T>{
  14.     @Override
  15.     public void add(T t) {
  17.     }
  18. }

11.5 类型通配符

image.png
image.png

十二、Map

12.1 map的概述和使用

image.png

  1. package demo12;
  3. import java.util.HashMap;
  5. public class TestHashMap {
  6.     public static void main(String[] args) {
  7. //                 <k,v> k=键类型 v=值类型
  8.         HashMap<Integer, String> map = new HashMap<>();
  9.         map.put(1,"张飞");
  10.         map.put(2,"张san");
  11.         map.put(3,"张飞");
  13.         System.out.println(map);
  15.     }
  16. }

12.2 map的常用方法

image.png

12.3 map的值获取

image.png

  1. package demo12;
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Set;
  8. public class TestHashMap {
  9.     public static void main(String[] args) {
  10. //                 <k,v> k=键类型 v=值类型
  11.         HashMap<Integer, String> map = new HashMap<>();
  12.         map.put(1,"张飞");
  13.         map.put(2,"张san");
  14.         map.put(3,"张飞");
  15. //    根据键拿到值
  16. //        System.out.println(map.get(1));
  17. //   拿到所有的键
  18. //        Set<Integer> integers = map.keySet();
  19. //        for (Integer integer : integers) {
  20. //            System.out.println(integer);
  21. //
  22. //        }
  23. //        拿到所有的values
  24. //        Collection<String> values = map.values();
  25. //        for (String value : values) {
  26. //            System.out.println(value);
  27. //
  28. //        }
  30. //        获取所有键值对对象的集合
  31.         Set<Map.Entry<Integer, String>> entries = map.entrySet();
  32.         for (Map.Entry<Integer, String> entry : entries) {
  33.             System.out.println(entry);
  35.         }
  37.     }
  38. }

12.4 map的遍历方式一

  1. //        map集合遍历1
  2. //        首先获取所有的key，通过getkey  拿到value
  3.         Set<Integer> integers = map.keySet();
  5.         for (Integer integer : integers) {
  6.             String s = map.get(integer);
  7.             System.out.println(integer+","+s);
  11.         }

12.4 map的遍历方式二

image.png

  1. //    map 集合遍历2
  3.         Set<Map.Entry<Integer, String>> entries = map.entrySet();
  4.         for (Map.Entry<Integer, String> entry : entries) {
  6.             Integer key = entry.getKey();
  7.             String value = entry.getValue();
  8.             System.out.println(key+":"+value);
  10.         }

12.5 map的遍历学生对象

  1. package demo12;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Set;
  8. public class TestHashMapStu {
  9.     public static void main(String[] args) {
  10. //
  11.         Student student1 = new Student("张飞",21);
  12.         Student student2 = new Student("刘备",22);
  13.         Student student3 = new Student("关羽",23);
  15.         HashMap<Integer, Student> map = new HashMap<>();
  16.         map.put(1,student1);
  17.         map.put(2,student2);
  18.         map.put(3,student3);
  19. //方式一遍历
  20.         Set<Integer> integers = map.keySet();
  21.         for (Integer integer : integers) {
  22.             Student student = map.get(integer);
  23.             System.out.println("key:"+integer+"   value:"+student.getName()+":"+student.getAge());
  24.         }
  25.         System.out.println("============================================");
  27.         Set<Map.Entry<Integer, Student>> entries = map.entrySet();
  28.         for (Map.Entry<Integer, Student> entry : entries) {
  30.             Integer integer = entry.getKey();
  31.             Student student = entry.getValue();
  33.             System.out.println("key:"+integer+"   value:"+student.getName()+":"+student.getAge());
  35.         }
  37.     }
  38. }