• Java2 - 数据结构

    5 数据类型

    5.1 整数类型

    在Java中，数据类型用于定义变量或表达式可以存储的数据的类型。Java的数据类型可分为两大类：基本数据类型和引用数据类型。

    • byte，字节 【1字节】表示范围：-128 ~ 127 即：-2^7 ~ 2^7 -1
    • short，短整型 【2字节】表示范围：-32768 ~ 32767
    • int，整型 【4字节】表示范围：-2147483648 ~ 2147483647
    • long，长整型 【8字节】表示范围：-9223372036854775808 ~ 9223372036854775807
    public class Hello {

    public static void main(String[] args) {
        byte v1 = 32;
        short v2 = 10000;
        int v3 = 22221331;
        long v4 = 554534353424L;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    需要注意的是，如果直接给 long 变量赋值，Java会将该值默认视为 int 类型，并且当值超出 int 的取值范围时会编译错误。因此，当给 long 变量赋一个超过 int 范围的值时，需要在数字后面加上 L 或 l 后缀，表示这个数字是 long 类型的常量。

    **提醒：**逆向时有一些字符串是通过字节数组来表示（UTF-8编码）

    v1 = "夏洛"
v2 = [-27, -92, -113, -26, -76, -101]

    • 1
    • 2

    案例

    import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        // 1.字节数组（转换为字符串） [字节,字节,字节]
        byte[] dataList = {97, 105, 100, 61, 50, 52, 54, 51, 56, 55, 53, 55, 49, 38, 97, 117, 116, 111, 95, 112, 108, 97, 121, 61, 48, 38, 99, 105, 100, 61, 50, 56, 57, 48, 48, 56, 52, 52, 49, 38, 100, 105, 100, 61, 75, 82, 69, 104, 69, 83, 77, 85, 74, 104, 56, 116, 70, 67, 69, 86, 97, 82, 86, 112, 69, 50, 116, 97, 80, 81, 107, 55, 87, 67, 104, 67, 74, 103, 38, 101, 112, 105, 100, 61, 48, 38, 102, 116, 105, 109, 101, 61, 49, 54, 50, 55, 49, 48, 48, 57, 51, 55, 38, 108, 118, 61, 48, 38, 109, 105, 100, 61, 48, 38, 112, 97, 114, 116, 61, 49, 38, 115, 105, 100, 61, 48, 38, 115, 116, 105, 109, 101, 61, 49, 54, 50, 55, 49, 48, 52, 51, 55, 50, 38, 115, 117, 98, 95, 116, 121, 112, 101, 61, 48, 38, 116, 121, 112, 101, 61, 51};
        String dataString = new String(dataList);
        System.out.println("字符串是：" + dataString);

        // 2.字符串->字节数组
        try {
            /*
            Python中的  name.encode("gbk") 
            string = "夏洛"
            byte_list = list(string.encode("gbk"))
            signed_byte_list = [byte if byte < 128 else byte - 256 for byte in byte_list]
            print(signed_byte_list)
            */
            
            String name = "夏洛";
            byte[] v1 = name.getBytes("GBK");
            System.out.println(Arrays.toString(v1)); //[-49, -60, -62, -27]
		
            // Python中的  name.encode("utf-8")
            byte[] v2 = name.getBytes("UTF-8");
            System.out.println(Arrays.toString(v2)); // [-27, -92, -113, -26, -76, -101]
        } catch (Exception e) {

        }
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    需求来了：某个app逆向，在Java代码中得到一个字节数组 [-49, -60, -62, -27]，请通过Python代码将这个字节数组转换成字符串？

    byte_list =[-49, -60, -62, -27]

bs = bytearray()  # python字节数组
for item in byte_list:
    if item < 0:
        item = item + 256
    bs.append(item)

str_data = bs.decode('gbk')  # data = bytes(bs)
print(str_data)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    5.2 字符
    char v1 = '夏';
char v2 = '洛';
String = "夏洛";

    • 1
    • 2
    • 3

    注意：字符串是由多个字符组成。

    5.3 字符串

    定义字符串

    String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

    import java.io.UnsupportedEncodingException;

public class Hello {

    public static void main(String[] args) throws UnsupportedEncodingException {
        String v1 = "夏洛";
        // 用构造函数创建字符串：
        String v2 = new String("夏洛");
        String v4 = new String(new byte[]{-27, -92, -113, -26, -76, -101});
        String v5 = new String(new byte[]{-49, -60, -62, -27}, "GBK");
        String v6 = new String(new char[]{'夏', '洛'}) ;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    字符串中的方法：

    public static void  demo2(){
    String origin = "请叫我靓仔AA";

    int len = origin.length();  // 长度
    for (int i = 0; i < len; i++) {
        char item = origin.charAt(i);
    }

    String v2 = origin.trim(); // 去除空白
    String v3 = origin.toLowerCase(); // 小写
    String v4 = origin.toUpperCase(); // 大写
    String[] v5 = origin.split("我"); // 分割
    String v6 = origin.replace("叫", "喊"); // 替换

    String v7 = origin.substring(2, 6);  // 子字符串=切片 [2:6]
    // equals() 方法用于判断 Number 对象与方法的参数进是否相等
    boolean v8 = origin.equals("请叫我"); // 
    // contains() 方法用于判断字符串中是否包含指定的字符或字符串。
    boolean v9 = origin.contains("el");
    // startsWith() 方法用于检测字符串是否以指定的前缀开始。
    boolean v10 = origin.startsWith("请");
    // concat() 方法用于将指定的字符串参数连接到字符串上。
    String v11 = origin.concat("哈哈哈"); 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    字符串拼接

    出现的点： 对请求参数和请求头 拼接在一起 做加密

    import java.io.UnsupportedEncodingException;

public class Hello {

    public static void main(String[] args) {
        // "name=alex&age=18"
        StringBuilder sb = new StringBuilder();  // StringBuffer线程安全
        sb.append("name");
        sb.append("=");
        sb.append("xialuo");
        sb.append("&");
        sb.append("age");
        sb.append("=");
        sb.append("18");
        String dataString = sb.toString();
        System.out.println(dataString);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    结果输出为：

    name=xialuo&age=18

    • 1

    python中的处理方式

    data = []
data.append("name")
data.append("=")
data.append("18")
data_string = "".join(data)

    • 1
    • 2
    • 3
    • 4
    • 5

    在这里插入图片描述

    5.4 数组

    存放固定长度的元素。

    • 容器
    • 固定长度
    • 特定类型
    import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // [123,1,999]
        int[] numArray = new int[3];
        numArray[0] = 123;
        numArray[1] = 1;
        numArray[2] = 99;
        System.out.println(Arrays.toString(numArray));
		
        // 同时定义和初始化数组
        String[] names = new String[]{"夏洛", "aa", "bb"};
        System.out.println(Arrays.toString(names));
        
        String[] nameArray = {"夏洛", "aa", "bb"};
        System.out.println(Arrays.toString(nameArray));
	
        // nameArray[0]
        // nameArray.length
        for (int idx = 0; idx < nameArray.length; idx++) {
            String item = nameArray[idx];
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    注意：数组一旦创建个数就不可调整。

    5.5 关于Object

    • 在Python中每个类都默认继承Object类（所有的类都是Object的子类）。

    • 在Java所有的类都是默认继承Object类。

      int v1 = 123;
String name = "夏洛";

      • 1
      • 2

      用基类可以泛指他的子类的类型。

    import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
 
        Object v1 = new String("xialuo");
        System.out.println(v1);
        System.out.println(v1.getClass());

        Object v2 = 123;
        System.out.println(v2);
        System.out.println(v2.getClass());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    案例一

    import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // 声明数组，数组中元素必须int类型;
        int[] v1 = new int[3];

        // 声明数组，数组中元素必须String类型;
        String[] v2 = new String[3];

        // 声明数组，数组中可以是数组中存储任何类型的对象
        Object[] v3 = new Object[3];
        v3[0] = 123;
        v3[1] = "xialuo";

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    所以，如果以后想要声明的数组中想要是混合类型，就可以用Object来实现。

    import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // v1是指上字符串对象；String
        String v1 = new String("xialuo");
        String res = v1.toUpperCase();
        System.out.println(res);

        // v2本质是字符串对象；Object
        Object v2 = new String("xialuo");
        String data = (String)v2;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    案例二

    import java.util.Arrays;

public class Hello {

    public static void func(Object v1) {
        // System.out.println(v1);
        // System.out.println(v1.getClass());
        if (v1 instanceof Integer) {
            System.out.println("整型");
        } else if (v1 instanceof String) {
            System.out.println("字符串类型");
        } else {
            System.out.println("未知类型");
        }
    }

    public static void main(String[] args) {
        func(123);
        func("123");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    6 常见数据类型

    6.1 List类型

    List是一个接口，接口下面有两个常见的类型（目的是可以存放动态的多个数据）

    • ArrayList，连续的内存地址的存储（内部自动扩容）。

    • LinkedList，底层基于链表实现（自行车链条）。

    • Java中所有的类都继承Object，Object代指所有的类型。

    • 自己创建关系

      在这里插入图片描述

    ArrayList v1 = new ArrayList();  // ArrayList 类实现了可变数组的大小  索引访问
LinkedList v2 = new LinkedList(); //LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素

    • 1
    • 2
    List v1 = new ArrayList();
List v2 = new LinkedList();

    • 1
    • 2
    Object v1 = new ArrayList();  
Object v2 = new LinkedList();

    • 1
    • 2

    案例一

    ArrayList v1 = new ArrayList();
v1.add("夏洛");
v1.add("麻子");

    • 1
    • 2
    • 3
    LinkedList v1 = new LinkedList();
v1.add("夏洛");
v1.add("麻子");

    • 1
    • 2
    • 3

    Java中接口，是用来约束实现他的类，约束他里面的成员必须有xx。

    interface List{
    public void add(Object data);   // 接口中的方法，不写具体的实现，只用于约束。
}

// 类ArrayList实现了接口List，此时这个类就必须有一个add方法。
class ArrayList implements List{
    public void add(Object data){
     	// 将数据data按照连续存储的方法放在内存。
        // ..
    }
}

// 类LinkedList实现了接口List，此时这个类就必须有一个add方法。
class LinkedList implements List{
    public void add(Object data){
     	// 将数据data按照链表的形式存储
        // ..
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    List v1 = new ArrayList();
v1.add("夏洛");
v1.add("麻子");

    • 1
    • 2
    • 3
    ArrayList

    ArrayList 是 Java 标准库中提供的一个类，它实现了 List 接口，可以用来管理一组对象。ArrayList 的特点是可以无限扩容，因此被广泛用于需要动态添加、删除元素的场景。

    1. 添加元素：
      • add(E element)：在列表末尾添加指定元素。
      • add(int index, E element)：在指定位置插入指定元素。
    2. 获取元素：
      • get(int index)：返回指定位置的元素。
    3. 移除元素：
      • remove(int index)：移除指定位置上的元素。
      • remove(Object obj)：移除第一个匹配指定对象的元素。
    4. 修改元素：
      • set(int index, E element)：替换指定位置上的元素。
    5. 查询和判断：
      • size()：返回列表中的元素数量。
      • isEmpty()：判断列表是否为空。
      • contains(Object obj)：判断列表是否包含指定对象。
    6. 清空和重置：
      • clear()：清空列表，将列表的大小重置为0。
    7. 转换为数组：
      • toArray()：将列表转换为数组。
    8. 遍历：
      • 使用传统的 for 循环、增强的 for-each 循环、迭代器等方式进行遍历。
    import java.util.ArrayList;
import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
		
        // ArrayList，默认内部存放的是混合数据类型。
        
        // ArrayList data = new ArrayList();
        // ArrayList data = new ArrayList();
        
        ArrayList data = new ArrayList();
        data.add("夏洛");
        data.add("aa");
        data.add(666);
        data.add("貂蝉");
		
        String value = data.get(1);
        value.length
            
        // String value = (String) data.get(1);
        Object temp = data.get(1);
        String value = (String) temp; // 转化可转换的数据
            
        System.out.println(value);

        int xo = (int) data.get(2);
        System.out.println(xo);

        data.set(0, "哈哈哈哈");
        System.out.println(data);

        data.remove("eric");
        data.remove(0);
        System.out.println(data);
		
        int size = data.size();
        System.out.println(size);
		
        boolean exists = data.contains("莹莹");
        System.out.println(exists);

		
        for (Object item : data) {
            System.out.println(item);
        }

        for (int i = 0; i < data.size(); i++) {
            Object item = data.get(i);
            System.out.println(item);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
     

    LinkedList
     

    LinkedList 是 Java 中的链表实现类，它实现了 List 接口和 Deque 接口，提供了对链表结构的支持。下面是一些 LinkedList 常用的方法：
     

    1. 添加元素： 
  
      • add(E element)：在链表末尾添加指定元素。
      • add(int index, E element)：在指定位置插入指定元素。
       
    2. 获取元素： 
  
      • get(int index)：返回指定位置的元素。
      • getFirst()：返回链表的第一个元素。
      • getLast()：返回链表的最后一个元素。
       
    3. 移除元素： 
  
      • remove(int index)：移除指定位置上的元素。
      • remove(Object obj)：移除第一个匹配指定对象的元素。
      • removeFirst()：移除链表的第一个元素。
      • removeLast()：移除链表的最后一个元素。
       
    4. 修改元素： 
  
      • set(int index, E element)：替换指定位置上的元素。
       
    5. 查询和判断： 
  
      • size()：返回链表中的元素数量。
      • isEmpty()：判断链表是否为空。
      • contains(Object obj)：判断链表是否包含指定对象。
       
    6. 清空和重置： 
  
      • clear()：清空链表。
       
    7. 队列操作： 
  
      • offer(E element)：将元素添加到链表末尾，相当于队列的入队操作。
      • poll()：移除并返回链表第一个元素，相当于队列的出队操作。
       
    8. 栈操作： 
  
      • push(E element)：将元素添加到链表的开头，相当于栈的入栈操作。
      • pop()：移除并返回链表的第一个元素，相当于栈的出栈操作。
       
    9. 遍历： 
  
      • 使用传统的 for 循环、增强的 for-each 循环、迭代器等方式进行遍历。
       
     

    import java.util.LinkedList;

public class Hello {

    public static void main(String[] args) {
        LinkedList<Integer> v1 = new LinkedList<Integer>();
        v1.add(11);
        v1.add(22);

        LinkedList<Object> v2 = new LinkedList<Object>();
        v2.add("有阪深雪");
        v2.add("大桥未久");
        v2.add(666);
        v2.add(123);

        //v2.remove(1);
        //v2.remove("哈哈");

        v2.set(2, "苍老师");
        v2.push("哈哈哈");
        // v2.addFirst(11);


        for (int i = 0; i < v2.size(); i++) {
            Object item = v2.get(i);
            System.out.println(item);
        }

        for (Object item : v2) {
            System.out.println(item);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
     

    关于迭代器：
     

    在Java中，迭代器（Iterator）是用于遍历集合（Collection）或数据结构中元素的接口。通过使用迭代器，我们可以按顺序访问集合中的每个元素，而无需了解底层集合的内部实现。
     

    import java.util.ArrayList;
import java.util.Iterator;

public class IteratorExample {
    public static void main(String[] args) {
        // 创建一个ArrayList集合
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");

        // 获取集合的迭代器
        Iterator<String> iterator = list.iterator();

        // 使用迭代器遍历集合元素
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
     

    在上面的代码中，我们创建了一个ArrayList集合并添加了一些元素。然后，通过调用iterator()方法获取了集合的迭代器对象，并使用hasNext()和next()方法进行迭代遍历。hasNext()方法用于检查是否还有下一个元素，next()方法用于返回当前元素并移动到下一个元素。
     

    需要注意的是，在使用迭代器遍历集合时，如果在遍历过程中修改了集合的结构（例如添加或删除元素），会抛出ConcurrentModificationException异常。因此，建议在使用迭代器遍历集合时不要对集合进行修改操作。
     

    迭代器是Java中常用的遍历集合的方式，它提供了一种统一的、可移植的遍历接口，并且支持在遍历过程中删除元素，是Java集合框架中重要的一部分。
     

    6.2 set系列
     

    Set是一个接口，常见实现这个接口的有两个类，用于实现不重复的多元素集合。
     

    • HashSet，去重，无序。
    • TreeSet，去重，内部默认排序（ascii、unicode）【不同的数据类型，无法进行比较】。
     

    import java.util.*;

public class Hello {

    public static void main(String[] args) {
        /*
方式一："HashSet s1 = new HashSet();" 使用具体的HashSet类作为声明类型，创建一个HashSet对象。这种方式限定了变量s1的类型为HashSet，只能调用HashSet类特有的方法。

方式二："Set s1 = new HashSet();" 使用Set接口作为声明类型，创建一个HashSet对象。这种方式使用了接口类型Set，可以调用Set接口中定义的所有方法，但无法直接调用HashSet类特有的方法。这种方式更加灵活，便于后续切换到其他实现Set接口的类，如TreeSet或LinkedHashSet。

方式三："HashSet s1 = new HashSet();" 使用泛型来指定集合中元素的类型。这种方式将HashSet限定为存储String类型的元素，可以确保在编译时期进行类型检查，避免插入不合法的元素类型到集合中。
        */
        // HashSet s1 = new HashSet();
        // Set s1 = new HashSet();
        // HashSet s1 = new HashSet();
        HashSet s1 = new HashSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");
        s1.add("P站");
        s1.add(666);
        System.out.println(s1); // [B站, A站, P站,666]
		
        // s2 = {"东京热","东北热","南京热"}
        HashSet s2 = new HashSet(){
            {
                add("东京热");
                add("东北热");
                add("南京热");
            }
        };
        System.out.println(s2); // [B站, A站, P站]



        // Set s2 = new TreeSet();
        // TreeSet s2 = new TreeSet();
        TreeSet s3 = new TreeSet();
        s3.add("P站");
        s3.add("B站");
        s3.add("A站");
        s3.add("P站");
        // s3.add(666); //不可以

        System.out.println(s3); // [B站, A站, P站]

        TreeSet s4 = new TreeSet(){
            {
                add("P站");
                add("B站");
                add("A站");
                add("P站");
            }
        };
        System.out.println(s4); // [B站, A站, P站]

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
     

    关于交并差：
     

    import java.util.*;

public class Hello {

    public static void main(String[] args) {
        // Set s1 = new HashSet();
        HashSet s1 = new HashSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");
        s1.remove("P站");
        System.out.println(s1); // [B站, A站, P站]

        boolean exists = s1.contains("B站");
        System.out.println(exists);

        HashSet s2 = new HashSet();
        s2.add(123);
        s2.add(456);

        HashSet v1 = new HashSet(); // 空 
        v1.addAll(s1);
        v1.retainAll(s2); // 交集 & 
        System.out.println(v1);


        HashSet v2 = new HashSet();
        v2.addAll(s1);
        v2.addAll(s2); // 并集 |
        System.out.println(v2);

        HashSet v3 = new HashSet();
        v3.addAll(s1);
        v3.removeAll(s2); // 差集 s1 - s2
        System.out.println(v3);


        HashSet v4 = new HashSet();
        v4.addAll(s2);
        v4.removeAll(s1); // 差集 s2 - s1
        System.out.println(v4);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
     

    关于循环获取：
     

    import java.util.*;

public class Hello {

    public static void main(String[] args) {

        TreeSet s1 = new TreeSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");

        for (Object item : s1) {
            System.out.println(item);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
     

    关于迭代器：
     

    使用Set集合的iterator()方法获取一个迭代器对象
     

    使用hasNext()方法检查迭代器是否有下一个元素。如果有，则执行相应的操作；如果没有，则退出循环。
     

    在循环内部，可以通过next()方法获取当前迭代器指向的元素
     

    import java.util.*;

public class Hello {

    public static void main(String[] args) {

        TreeSet s1 = new TreeSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");

        Iterator it = s1.iterator();
        while (it.hasNext()) {
            String item = (String) it.next();
            System.out.println(item);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
     

    6.3 map系列
     

    Map是一个接口，常见实现这个接口的有两个类，用于存储键值对。
     

    •  
      HashMap，是基于哈希表实现的Map，它提供了快速的插入、查找和删除操作。键值对的存储是无序的，在大部分情况下是最常用的Map实现类。
       
    •  
      TreeMap，默认根据key排序。（常用）
       
     

    HashMap
     

    import java.util.*;

public class Hello {

    public static void main(String[] args) {
        HashMap h1 = new HashMap();
        h1.put("name","xialuo");
        h1.put("age",18);
        h1.put("hobby","男");
        System.out.println(h1); 
		
        // 特定数据类型  字符串
        HashMap<String,String> h2 = new HashMap<String,String>();
        h2.put("name","xialuo");
        h2.put("age","18");
        h2.put("hobby","男");
        System.out.println(h2); 
		
        // 声明 初始化值 
        HashMap<String,String> h3 = new HashMap<String,String>(){
            {
                put("name","xialuo");
                put("age","18");
                put("hobby","男");
            }
        };
        System.out.println(h3);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
     

    TreeMap
     

    TreeMap 是 Map 接口的一个实现类，它基于红黑树（Red-Black Tree）实现，可以保持键的有序性。相比于 Map 接口中通用的方法，TreeMap 中具有以下一些特有的方法：
     

    1. firstKey()：返回最小键。
    2. lastKey()：返回最大键。
    3. floorKey(K key)：返回小于等于指定键的最大键，如果不存在这样的键，则返回 null。
    4. ceilingKey(K key)：返回大于等于指定键的最小键，如果不存在这样的键，则返回 null。
    5. lowerKey(K key)：返回小于指定键的最大键，如果不存在这样的键，则返回 null。
    6. higherKey(K key)：返回大于指定键的最小键，如果不存在这样的键，则返回 null。
    7. descendingKeySet()：返回按逆序遍历此映射中的键所构成的集合。
     

    import java.util.*;

public class Hello {

    public static void main(String[] args) {
        
        TreeMap h1 = new TreeMap(); // 改为了TreeMap
        h1.put("name","xialuo");
        h1.put("age",18);
        h1.put("hobby","男");
        System.out.println(h1); // {age=18, hobby=男, name=xialuo}
		
        // 固定类型
        TreeMap<String,String> h2 = new TreeMap<String,String>();
        h2.put("name","xialuo");
        h2.put("age","18");
        h2.put("hobby","男");
        System.out.println(h2); 
		
		// 声明 初始化值 
        TreeMap<String,String> h3 = new TreeMap<String,String>(){
            {
                put("name","xialuo");
                put("age","18");
                put("hobby","男");
            }
        };
        System.out.println(h3);
		
		// 只能调用 Map 接口中定义的方法，不能直接调用 TreeMap 特有的方法
        Map h4 = new TreeMap();
        h4.put("name","xialuo");
        h4.put("age",18);
        h4.put("hobby","男");
        System.out.println(h4);
        // h4.firstKey();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
     

    python中使用需要排序处理
     

    在Python中需要自己处理key排序的问题。
v4 = {
	"aid":123,
	"xx":999,
	"wid":888
}

# 1.python 根据key进行排序
# data = ["{}={}".format(key,v4[key])  for key in sorted(v4.keys())]

# 2.再进行拼接
# result = "&".join(data)

result = "&".join(["{}={}".format(key,v4[key])  for key in sorted(v4.keys())])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
     

    TreeMap常见操作：
     

    import java.util.*;

public class Hello {

    public static void main(String[] args) {
        TreeMap h1 = new TreeMap(); // 改为了TreeMap
        h1.put("name", "xialuo");
        h1.put("age", "18");
        h1.put("hobby", "男");
        h1.put("hobby", "女人");
	
        h1.remove("age");
        int size = h1.size();

        Object value = h1.get("name"); // 不存在，返回null
        System.out.println(value);

        boolean existsKey = h1.containsKey("age");
        boolean existsValue = h1.containsValue("xialuo");
		
        // 替换
        h1.replace("name", "李杰");
        System.out.println(h1);


        // 循环: 示例1
        // {  ("name", "xialuo")，("age", "18"),  }
        Set<Map.Entry<String, String>> s1 = h1.entrySet();
        Iterator it1 = s1.iterator();
        while (it1.hasNext()) {
            // ("name", "xialuo")
            Map.Entry<String, String> entry = (Map.Entry<String, String>) it1.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
        }

        // 循环: 示例2
        Set s2 = h1.entrySet();
        Iterator it2 = s2.iterator();
        while (it2.hasNext()) {
            Map.Entry entry = (Map.Entry) it2.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
        }

        // 循环: 示例3
        TreeMap<String, String> h2 = new TreeMap<String, String>(); // 改为了TreeMap
        h2.put("name", "xialuo");
        h2.put("age", "18");
        for (Map.Entry<String, String> entry : h2.entrySet()) {
            String k = entry.getKey();
            String v = entry.getValue();
        }

        // 循环: 示例4
        TreeMap h3 = new TreeMap(); // 改为了TreeMap
        h3.put("name", "xialuo");
        h3.put("age", 18);
        
        for (Object entry : h3.entrySet()) {
            Map.Entry<String, Object> entryMap = (Map.Entry<String, Object>) entry;
            String k = entryMap.getKey();
            Object v = entryMap.getValue(); // 18   "xialuo"
            
            if (v instanceof Integer) {
                System.out.println("数字：" + Integer.toString((Integer) v));
            } else if (v instanceof String) {
                System.out.println("字符串：" + (String) v);
            } else {
                System.out.println("未知类型：" + v.toString());
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
     

    尝试用python还原
     在这里插入图片描述
     

    在这里插入图片描述
    
                
                    
                

                
  • 

                    相关阅读:
    
                    
BiMPM实战文本匹配【上】                            
    
红路灯识别                            
    
ECharts数据可视化项目【6】                            
    
JDK的动态代理，一文搞定                            
    
think-rom(thinkphp) 数据库参数绑定bigint被处理成浮点数(科学计数)问题                            
    
如何分析排序算法                            
    
Redis从入门到精通（四：持久化）                            
    
机器学习知识总结 —— 15. 什么是支持向量机（对偶问题、核技巧）？                            
    
修改oem.img镜像文件                            
    
Spring的创建与使用                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/afangxin/article/details/134247931
                
    •