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;}
}

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

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

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

案例

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) {}}}

需求来了：某个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 + 256bs.append(item)str_data = bs.decode('gbk')  # data = bytes(bs)
print(str_data)

5.2 字符

char v1 = '夏';
char v2 = '洛';
String = "夏洛";

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

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[]{'夏', '洛'}) ;}
}

字符串中的方法：

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("哈哈哈"); 
}

字符串拼接

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

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);}
}

结果输出为：

name=xialuo&age=18

python中的处理方式

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

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.lengthfor (int idx = 0; idx < nameArray.length; idx++) {String item = nameArray[idx];}}
}

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

5.5 关于Object

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

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

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

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

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());}
}

案例一

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";}
}

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

import java.util.Arrays;public class Hello {public static void main(String[] args) {// v1是指上字符串对象；StringString v1 = new String("xialuo");String res = v1.toUpperCase();System.out.println(res);// v2本质是字符串对象；ObjectObject v2 = new String("xialuo");String data = (String)v2;}
}

案例二

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");}
}

6 常见数据类型

6.1 List类型

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

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

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

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

• 自己创建关系

  

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

List v1 = new ArrayList();
List v2 = new LinkedList();

Object v1 = new ArrayList();  
Object v2 = new LinkedList();

案例一

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

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

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按照链表的形式存储// ..}
}

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

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<String> data = new ArrayList<String>();// ArrayList<Object> data = new ArrayList<Object>();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);}}
}

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);}}
}

关于迭代器：

在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);}}
}

在上面的代码中，我们创建了一个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<String> s1 = new HashSet<String>();" 使用泛型来指定集合中元素的类型。这种方式将HashSet限定为存储String类型的元素，可以确保在编译时期进行类型检查，避免插入不合法的元素类型到集合中。*/// HashSet s1 = new HashSet();// Set s1 = new HashSet();// HashSet<String> s1 = new HashSet<String>();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<String> s2 = new TreeSet<String>();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站]}
}

关于交并差：

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 - s2System.out.println(v3);HashSet v4 = new HashSet();v4.addAll(s2);v4.removeAll(s1); // 差集 s2 - s1System.out.println(v4);}
}

关于循环获取：

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);}}
}

关于迭代器：

使用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);}}
}

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);}
}

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(); // 改为了TreeMaph1.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();}
}

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())])

TreeMap常见操作：

import java.util.*;public class Hello {public static void main(String[] args) {TreeMap h1 = new TreeMap(); // 改为了TreeMaph1.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"); // 不存在，返回nullSystem.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();}// 循环: 示例2Set 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();}// 循环: 示例3TreeMap<String, String> h2 = new TreeMap<String, String>(); // 改为了TreeMaph2.put("name", "xialuo");h2.put("age", "18");for (Map.Entry<String, String> entry : h2.entrySet()) {String k = entry.getKey();String v = entry.getValue();}// 循环: 示例4TreeMap h3 = new TreeMap(); // 改为了TreeMaph3.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());}}}
}

尝试用python还原