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 + 256
bs.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.length
for (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是指上字符串对象；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;
}
}
案例二
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 的特点是可以无限扩容，因此被广泛用于需要动态添加、删除元素的场景。
- 添加元素：
add(E element)：在列表末尾添加指定元素。add(int index, E element)：在指定位置插入指定元素。
- 获取元素：
get(int index)：返回指定位置的元素。
- 移除元素：
remove(int index)：移除指定位置上的元素。remove(Object obj)：移除第一个匹配指定对象的元素。
- 修改元素：
set(int index, E element)：替换指定位置上的元素。
- 查询和判断：
size()：返回列表中的元素数量。isEmpty()：判断列表是否为空。contains(Object obj)：判断列表是否包含指定对象。
- 清空和重置：
clear()：清空列表，将列表的大小重置为0。
- 转换为数组：
toArray()：将列表转换为数组。
- 遍历：
- 使用传统的
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 常用的方法：
- 添加元素：
add(E element)：在链表末尾添加指定元素。add(int index, E element)：在指定位置插入指定元素。
- 获取元素：
get(int index)：返回指定位置的元素。getFirst()：返回链表的第一个元素。getLast()：返回链表的最后一个元素。
- 移除元素：
remove(int index)：移除指定位置上的元素。remove(Object obj)：移除第一个匹配指定对象的元素。removeFirst()：移除链表的第一个元素。removeLast()：移除链表的最后一个元素。
- 修改元素：
set(int index, E element)：替换指定位置上的元素。
- 查询和判断：
size()：返回链表中的元素数量。isEmpty()：判断链表是否为空。contains(Object obj)：判断链表是否包含指定对象。
- 清空和重置：
clear()：清空链表。
- 队列操作：
offer(E element)：将元素添加到链表末尾，相当于队列的入队操作。poll()：移除并返回链表第一个元素，相当于队列的出队操作。
- 栈操作：
push(E element)：将元素添加到链表的开头，相当于栈的入栈操作。pop()：移除并返回链表的第一个元素，相当于栈的出栈操作。
- 遍历：
- 使用传统的
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 - s2
System.out.println(v3);
HashSet v4 = new HashSet();
v4.addAll(s2);
v4.removeAll(s1); // 差集 s2 - s1
System.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 中具有以下一些特有的方法：
firstKey()：返回最小键。lastKey()：返回最大键。floorKey(K key)：返回小于等于指定键的最大键，如果不存在这样的键，则返回 null。ceilingKey(K key)：返回大于等于指定键的最小键，如果不存在这样的键，则返回 null。lowerKey(K key)：返回小于指定键的最大键，如果不存在这样的键，则返回 null。higherKey(K key)：返回大于指定键的最小键，如果不存在这样的键，则返回 null。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();
}
}
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(); // 改为了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());
}
}
}
}
尝试用python还原
![[架构之路-244]：目标系统 - 设计方法 - 软件工程 - 软件开发方法与软件开发模型](https://img-blog.csdnimg.cn/b79e10d096be430f8ecf74298095e95a.png)
