# pingtu

**Repository Path**: unfetteredman/pingtu

## Basic Information

- **Project Name**: pingtu
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-04-23
- **Last Updated**: 2024-09-07

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# java笔记

> 当前markdown所在的项目jdk隶属于17版本

## Math

> java内置数学方法方法

1. abs(int number); 范围： -2147483648 - 2147483647
2. ceil(-12.34); 向上取整，负数近 1法
3. floor(double 3.14); 向下取整
4. round(double -3.54); 4 四舍五入
5. max(int 30, int 40); 获取两个整数最小值
6. min(int 20, int 20); 获取最小值
7. pow(int 3, int 4); a的b次幂
8. sqrt 开平方根
9. cbrt 开立方根
10. random [0.0 - 1.0)；之间的整数

## System

> System 系统工具类

1. exit(int status) 退出当前运行的虚拟机
2. currentTimeMillis() 返回当前系统的时间毫秒
3. arraycopy（数据源数组，起始索引，目的地数组，起始索引，拷贝个数） 数组拷贝

## RunTime

> 当前程序运行的环境对象

1. getRunTime（） 获取RunTime对象
2. exit（int status）退出虚拟机
3. availableProcessors（）获得cpu线程数
4. maxMemory（）JVM从内存获取的总内存大小，单位byte
5. totalMemroy（） JVM从内存已经获取的总内存大小，单位byte
6. freeMemory（）JVM剩余内存
7. exec（String commond） 运行cmd命令

```java

// 获取Runtime实例，Runtime是静态class
 Runtime r = Runtime.getRuntime();

```

## Object

> Object 是所有类的顶级父类

1. public String toString（）；返回对象的字符串表示形式
2. public Boolean equals（Object obj）;判断两个对象是否相等；
3. protect Object clone（int a）；对象克隆，
   - 首先要重写Object的clone方法
   - 让当前的JavaBean类实现Cloneable接口
   - 创建原对象并调用clone方法
     ```java
         // 必须实现Cloneable
         public class User implements Cloneable{
             int[] data = {1, 2, 3};
                    
             // 浅克隆
             @Override
             protected Object clone()throws CloneNotSupportedException {
               return super.clone();
             }
             // 深克隆
             @Override
             protected Object clone()throws CloneNotSupportedException {
                 int[] newData = new int[data.length];
                 for(int i = 0;  i < data.length; i++) {
                     newData[i] = data[i];
                 }
                User s = super.clone();
                s.data = newData;
               return s;
             }
         }   
         public class Test {
             public static void main(String[] args){
               User user1 = new User();
               // 调用clone方法就可克隆
               User user2 = (User) user1.clone();
             }
         }
                
     ```
## Objects

> Objects 是一个工具类，提供了一些操作对象方法完成对应的功能

1. public static Boolean equals (Object a, Object b); 先做非空判断，比较两个对象
2. public static Boolean isNull (Object a); 判断对象是否为null， 为null返回true，否则返回false
3. publci static Boolearn nonNull (Object a); 判断对象是否为null，和isNull结果相反；

## BigInteger

### BigInteger 创建BigInteger方法

1. public BigInteger(int num, Random rnd); 获取随机大整数，范围[0 - 2的num次方 -1]
2. public BigInteger(String val)； 获取指定的大整数
3. public BigInteger(String val，int radix)； 获取指定进制的大整数
4. public static BigInteger valueOf（long val）静态方法，获取BigInteger对象

    ```java
   
        import java.math.BigInteger;
        bigInteger b1 = BigInteger.valueOf(2999); // 使用静态方法创建
        bigInteger b2 = new BigInteger("988923"); //使用构造方法创建；
        
    ```
### BigInteger 内置方法
    
1. public BigInteger add (BigInteger val); 加
2. public BigInteger subtract (BigInteger val); 减
3. public BigInteger multiply (BigInteger val); 乘，
4. public BigInteger divide (BigInteger val); 除法，获取商
5. public BigInteger[] divideAndRemainder (BigInteger val);  除法，获取商和余数
6. public Boolean equals (BigInteger val); 比较是否相等
7. public BigInteger pow (BigInteger val); 次幂
8. public BigInteger min/max (BigInteger val); 返回最小值或者最大值
9. public int intValue (BigInteger val); 转为int类型整数，超出范围会报错

## BigDecimal

1. public BigDecimal(Double num); 这样创建的浮点数比较会不精确
2. public BigDecimal(String val)； 获取指定的浮点数，比较比较精确
3. public static BigDecimal  valueOf（Double val）静态方法，获取BigInteger对象

    ```java
   
        import java.math.BigDecimal;
        BigDecimal b1 = BigDecimal.valueOf(2999); // 使用静态方法创建
        BigDecimal b2 = new BigDecimal("988923"); //使用构造方法创建；
        
    ```
### BigInteger 内置方法

1. public BigDecimal add (BigDecimal val); 加
2. public BigDecimal subtract (BigDecimal val); 减
3. public BigDecimal multiply (BigDecimal val); 乘，
4. public BigDecimal divide (BigDecimal val); 除法
5. public BigDecimal divide (BigDecimal val，精确几位，舍入模式);  除法，

## 正则

![img_1.png](img_1.png)
![img_2.png](img_2.png)
![img_3.png](img_3.png)

### Pattern

```java
   import java.util.regex.Matcher;
import java.util.regex.Pattern;

String str = "Java中，java8 和java17讲在未来出现";

public static void main(String[] args) {

   Pattern p = Pattern.compile("Java\\d{0, 2}");

// 文本匹配器
   Matcher m = p.matcher(str);

   boolean b = m.find();

   String s  = m.group();
// 也可以通过while循环去获取所有匹配字符串；
   while(m.find())  {
      boolean b = m.find();

      String s  = m.group();
   }
}
    
    
```

### 利用正则去爬取网络信息
   ![img_4.png](img_4.png)
   
### ?i ?= ?: ?!

![img_5.png](img_5.png)

### 贪婪爬取和非贪婪爬取
#### 非贪婪爬取
   - +？
   - *?
#### 贪婪爬取
   ab+ 会爬取abbbbb

![img_6.png](img_6.png)

![img_7.png](img_7.png)

## String
   - Public String replaceAll（String regx， String newStr）
   - publci string[] split(String regx)

## Date

![img_8.png](img_8.png)

## SimpleDateFormat格式化时间

```java

import java.text.SimpleDateFormat;
import java.util.Calendar;

String str = "2023年03月02日";

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

Date d = sdf.parse(str);
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss EE");

String s = sdf2.format(d);



```

## Calendar 时间操作类
![img_9.png](img_9.png)

![img_10.png](img_10.png)

## jdk8 新增的时间对象

![img_11.png](img_11.png)

### Zoneld

![img_12.png](img_12.png)

### Instant时间戳

![img_13.png](img_13.png)

### ZoneDateTime

![img_14.png](img_14.png)

### DateTimeFormatter

![img_15.png](img_15.png)

![img_16.png](img_16.png)
![img_17.png](img_17.png)

## 包装类

![img_18.png](img_18.png)

### Integer 包装类

![img_19.png](img_19.png)

## 二分查找
![img_21.png](img_21.png)
![img_20.png](img_20.png)

## 插值查找
![img_22.png](img_22.png)

![img_23.png](img_23.png)

## 排序
![img_24.png](img_24.png)

### 冒泡排序
```java
 public static int[] maoPao(int[] arr) {
        if(arr.length == 0) {
            return arr;
        }
        for (int j = 0; j < arr.length; j++) {
            for (int i = 0; i < arr.length-1 -j; i++) {
                if(arr[i] > arr[i+1]) {
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }

        return  arr;
    }
```
![img_26.png](img_26.png)

### 选择排序

![img_27.png](img_27.png)

```java
public static int[] xuanZeOrder(int[] arr) {
        for (int i = 0; i < arr.length -1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return  arr;
    }
```

### 插入排序

![img_28.png](img_28.png)

```java

private static int[] chaRuOder(int[] arr) {
        int startIndex = -1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > arr[i + 1]) {
                startIndex = i + 1;
                break;
            }
        }

        for (int i = startIndex; i < arr.length; i++) {
            int j = i;
            while (j> 0 && arr[j] < arr[j-1]) {
                int temp = arr[j];
                arr[j] = arr[j -1];
                arr[j-1] = temp;
                j--;
            }
        }
        return  arr;
    }
```

### 快速排序

![img_29.png](img_29.png)

```java
public static  void quickOrder(int[] arr, int i, int j){
        int start = i;
        int end = j;
        if(start > end) {
            return;
        }
        int baseNumber = arr[i];
        // 必须从end开始
        // 利用end从后往前找，找比基准数小的数字
        while (start != end) {
            while (true) {
                if (start >= end || arr[end] < baseNumber ) {
                    break;
                }
                end--;
            }
            while (true) {
                if (start >= end || arr[start] > baseNumber ) {
                    break;
                }
                start++;
            }
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;
        // 确定基准数左边范围，重复
        quickOrder(arr, i, start -1);
        // 确定基准数右边范围，重复
        quickOrder(arr, start + 1, j);
    }
```
![img_30.png](img_30.png)

## Arrays 操作数组的工具类

![img_31.png](img_31.png)

```java
import java.util.Arrays;

public static void main(String[] args) {
   Arrays.toString({1,2,3,4,5});
}
```


## lambda

![img_32.png](img_32.png)
![img_33.png](img_33.png)

```java
package com.itheima.test;

public class LambdaTest {
    public static void main(String[] args){
        goSwimming(new Swim() {
            @Override
            public void swimming() {
                System.out.println("go swimming !~!");
            }
        });
        goSwimming(() -> System.out.println("lambda go swimming !~!"));
    }
    public static void goSwimming(Swim s) {
        s.swimming();
    }
}

interface Swim {
    public abstract void swimming();
}
```

![img_34.png](img_34.png)

![img_35.png](img_35.png)

![img_36.png](img_36.png)

<<<<<<< HEAD
## 集合体系结构

![img_32.png](img_32.png)

![img_33.png](img_33.png)

![img_34.png](img_34.png)
![img_35.png](img_35.png)

![img_36.png](img_36.png)

![img_37.png](img_37.png)

![img_38.png](img_38.png)

![img_39.png](img_39.png)

![img_40.png](img_40.png)

![img_41.png](img_41.png)

![img_42.png](img_42.png)

![img_43.png](img_43.png)

![img_44.png](img_44.png)

![img_45.png](img_45.png)

![img_46.png](img_46.png)

![img_47.png](img_47.png)

![img_50.png](img_50.png)
![img_48.png](img_48.png)

## 数据结构

![img_51.png](img_51.png)

### 栈
![img_52.png](img_52.png)

### 队列

![img_53.png](img_53.png)

### 数组

![img_54.png](img_54.png)

### 链表

![img_55.png](img_55.png)

![img_56.png](img_56.png)

![img_57.png](img_57.png)

![img_58.png](img_58.png)

![img_49.png](img_49.png)


## ArrayList

![img_59.png](img_59.png)

![img_60.png](img_60.png)

## 泛型

![img_61.png](img_61.png)

![img_62.png](img_62.png)

![img_63.png](img_63.png)

![img_64.png](img_64.png)

![img_65.png](img_65.png)

![img_66.png](img_66.png)

# 二叉树

![img_67.png](img_67.png)

![img_68.png](img_68.png)
![img_71.png](img_71.png)
![img_70.png](img_70.png)
![img_69.png](img_69.png)


![img_72.png](img_72.png)

![img_73.png](img_73.png)



## 平衡二叉树

![img_74.png](img_74.png)

### 左旋


![img_75.png](img_75.png)

### 右旋

![img_76.png](img_76.png)

![img_77.png](img_77.png)

## 红黑树（B树）

![img_78.png](img_78.png)

![img_79.png](img_79.png)


![img_80.png](img_80.png)

![img_81.png](img_81.png)


![img_82.png](img_82.png)

## Set集合

![img_83.png](img_83.png)

![img_84.png](img_84.png)


![img_85.png](img_85.png)

![img_86.png](img_86.png)


![img_87.png](img_87.png)

### hashSet

![img_88.png](img_88.png)

![img_89.png](img_89.png)


![img_90.png](img_90.png)


### linkedHashSet

![img_91.png](img_91.png)


![img_92.png](img_92.png)


### treeSet
![img_93.png](img_93.png)

![img_94.png](img_94.png)


![img_95.png](img_95.png)

![img_97.png](img_97.png) 

![img_98.png](img_98.png)

![img_96.png](img_96.png)

![img_99.png](img_99.png)


![img_100.png](img_100.png)

## Map


![img_101.png](img_101.png)

![img_102.png](img_102.png)

![img_103.png](img_103.png)

### map的第一种遍历，通过键找值


![img_104.png](img_104.png)

### map的第二种遍历，通过 key-value
![img_105.png](img_105.png)

### 通过lamdbab表达式

![img_106.png](img_106.png)

![img_107.png](img_107.png)


## hashMap

![img_108.png](img_108.png)

![img_109.png](img_109.png)
```java

public class StudentMapTest {
    public static void main(String[] args) {
        
        // 创建HashMap对象
        HashMap<Student, String> hm = new HashMap<>();

        Student s1 =  new Student(18, "zhangsan");
        Student s2 = new Student(23, "wangwu");
        Student s3 = new Student(19, "lisi");

        hm.put(s1, "四川");
        hm.put(s2, "甘肃");
        hm.put(s3, "江苏");

        Set<Student> keys = hm.keySet();
        for (Student key : keys) {
            String val = hm.get(key);
            System.out.println(val);
        }

        Set<Map.Entry<Student, String>> entries = hm.entrySet();
        for (Map.Entry<Student, String> entry : entries) {
            Student key = entry.getKey();
            String val = entry.getValue();
            System.out.println(key);
            System.out.println(val);
        }
        System.out.println("=============================");
        hm.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student student, String s) {
                System.out.println(student);
                System.out.println(s);
            }
        });
        System.out.println("================2=============");
        hm.forEach(( student, s) ->{
                System.out.println(student);
                System.out.println(s);
            }
        );
    }
}

```

### linkedHashMap
![img_110.png](img_110.png)

```java
import java.util.LinkedHashMap;

public class Test {
   public static void main(String[] args) {
      LinkedHashMap<String, Integer> lhm = new LinkedHashMap();
      lhm.put("a", 32);
      
   }
}
```

### TreeMap

![img_111.png](img_111.png)

```java
public class TreeMapTest {
    public static void main(String[] args) {
        //TreeMap<Integer, String> tm = new TreeMap<>();
        // 创建时定义排序规则
        TreeMap<Integer, String> tm = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // o1 要添加的元素， o2，红黑树已经存在的元素
                return o2 - o1;
            }
        });

        tm.put(1, "xiaoming");
        tm.put(3, "xiaoming");
        tm.put(2, "xiaoming");
        tm.put(4, "xiaoming");

        for (Integer i : tm.keySet()) {
            System.out.println(i);
        }



    }
}

```

```java


// 实现 Comparable 接口的 compareTo 方法进行比较
public class Student implements Comparable<Student> {

    public int age;
    public String name;

    public Student() {
    }

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }

    public String toString() {
        return "Student{age = " + age + ", name = " + name + "}";
    }

    @Override
    public int compareTo(Student o) {
        int i = this.getAge() - o.getAge();
        i =  i == 0 ?  this.getName().compareTo(o.getName()) : i;
        return i;
    }
}

```
### 总结
![img_112.png](img_112.png)


## 可变参数

![img_113.png](img_113.png)


## Collections

![img_114.png](img_114.png)

## 不可变集合

![img_115.png](img_115.png)

```java
import java.util.Iterator;
import java.util.List;

public static void main(String[] args) {
    List<String> str = List.of("1", "s", "a");

    Iterator<String> iterator = str.iterator();

    while (iterator.hasNext()) {
        String next = iterator.next();
        System.out.println(next);
    }
}
```

![img_116.png](img_116.png)

```java
import java.util.Set;

public static void main(String[] args) {
    Set<String> s = Set.of("a", "b");
}
```

![img_117.png](img_117.png)

![img_118.png](img_118.png)

```java
import java.util.Map; 

public class Test {
    public static void main(String[] args) {
        Map<String, String> map = Map.of("key1", "value1", "key2", "value2");
    }
}
```

![img_119.png](img_119.png)

![img_121.png](img_121.png)

![img_120.png](img_120.png)


![img_122.png](img_122.png)


## stream 流

![img_123.png](img_123.png)

![img_124.png](img_124.png)

```java
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.function.Consumer;

public class Test {
   public static void main(String[] args) {
      ArrayList<String> list = new ArrayList<>();
      Collections.addAll(list, "a", "b", "C");

      //1 
      list.stream().forEach(new Consumer<String>() {
         @Override
         public void accept(String s) {
            System.out.println(s);
         }
      });
      // 2
      list.stream().forEach(s -> System.out.println(s));

      HashMap<String, String> hm = new HashMap<>();
      
      hm.put("a", "xiaoming");
      hm.put("b", "wangwu");
      hm.put("c", "lisi");
      hm.put("d", "pink");
      
      //第一张获取stream流
      hm.keySet().stream().forEach(s -> System.out.println(s));
      
      // 第二种
      
      hm.entrySet().stream().forEach(entry -> System.out.println(entry));
      
   }
}
```

![img_125.png](img_125.png)

![img_126.png](img_126.png)

![img_127.png](img_127.png)


![img_128.png](img_128.png)

![img_129.png](img_129.png)

![img_130.png](img_130.png)

![img_131.png](img_131.png)

![img_134.png](img_134.png)
![img_132.png](img_132.png)
![img_133.png](img_133.png)

![img_135.png](img_135.png)

### LinkedHashMap
![img_136.png](img_136.png)

```java

public class LinkedHashMapTest {
    public static void main(String[] args) {
       LinkedHashMap<String, Integer> hm =   new LinkedHashMap<>();
       hm.put("a", 1);
       hm.put("b", 2);
       hm.put("a", 3);

       hm.forEach(new BiConsumer<String, Integer>() {
           @Override
           public void accept(String s, Integer integer) {
               System.out.println(s + "=" +integer);
           }
       });
        System.out.println(hm);
    }
}

```

### TreeMap

![img_137.png](img_137.png)

```java
public class TreeMapTest {
    public static void main(String[] args) {
        TreeMap<String, Integer> tm = new TreeMap<>();

        tm.put("a", 1);
        tm.put("c", 3);
        tm.put("b", 2);
        System.out.println(tm);
        
        // 可以传入Comparator实现方法修改默认排序方式
        TreeMap<String, Integer> tm2 = new TreeMap<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });

        tm2.put("a", 1);
        tm2.put("c", 3);
        tm2.put("b", 2);
        System.out.println(tm2);
    }
}

```

### stream流

![img_138.png](img_138.png)

```java
import java.util.stream.Stream;

public class StreamTest {
   public static void main(String[] args) {
      // 单列集合
      ArrayList<String> list = new ArrayList<>();
      Collections.addAll(list, "a", "b", "c", "D");
      Stream<String> streams = list.stream();
      streams.forEach(new Consumer<String>() {
         @Override
         public void accept(String s) {
            System.out.println(s);
         }
      });
      list.stream().forEach(s -> System.out.println(s));
      //双列集合
      HashMap<Object, Object> hm = new HashMap<>();
      hm.put("a", 111);
      hm.put("b", 222);
      hm.put("c", 333);
      hm.keySet().stream().forEach(k -> System.out.println(k));
      hm.entrySet().stream().forEach(et -> System.out.println(et));
      // 数组
      // 基本数据类型
      int[] arr1 = {1, 2, 3, 4, 5};
      // 引用数据类型
      String[] arr2 = {"1", "2", "3"};
      Arrays.stream(arr1).forEach(i -> System.out.println(i));
      Arrays.stream(arr2).forEach(s -> System.out.println(s));
      //注意： 也可以直接将引用数据类型用Stream.of，但是不能直接用基本数据类型
      Stream.of(arr2).forEach(i -> System.out.println(i));

      // 一堆零散数据，必须同种数据类型;
      Stream.of(1, 2, 3).forEach(i -> System.out.println(i));
      Stream.of("a", "b", "c").forEach(s -> System.out.println(s));
   }
}

```