一 python和java字节字符串比较

1.1字符串常用方法

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
String origin = "hello world 中国";

// 1 取指定位置字符
char v1 = origin.charAt(13); // 取出字符 国
System.out.println(v1);

// 2 循环输出每个字符
int len = origin.length(); // 字符串长度
for (int i = 0; i < len; i++) {
char item = origin.charAt(i);
System.out.println(item);
}
// 3 去除前后空白
String v2 = origin.trim(); // 去除空白
System.out.println(v2);
// 4 转大写
String v3 = origin.toLowerCase(); // 小写
System.out.println(v3);
String v4 = origin.toUpperCase(); // 大写
System.out.println(v4);
String[] v5 = origin.split(" "); // 按空格分隔
System.out.println(v5);
String v6 = origin.replace("h", "l"); // 把h替换为l
System.out.println(v6);
String v7 = origin.substring(2, 6); // 子字符串=切片 [2:6]
System.out.println(v7);
boolean v8 = origin.equals("hello world"); // 比较字符串是否相等
System.out.println(v8);
boolean v9 = origin.contains("中"); // 字符串是否包含
System.out.println(v9);
boolean v10 = origin.startsWith("a"); // 字符串是否以xx开头
System.out.println(v10);
String v11 = origin.concat("哈哈哈"); //在字符串末尾追加
System.out.println(v11);

1.2字符串拼接

1
2
3
4
5
6
7
8
9
10
11
12
13
### 1 直接相加,效率低
String s="hello"+"world"+"中国";

### 2 使用StringBuilder或StringBuffer拼接
StringBuilder sb = new StringBuilder(); // StringBuffer线程安全
//StringBuffer sb = new StringBuffer(); // StringBuffer线程安全
sb.append("hello");
sb.append(" ");
sb.append("world");
sb.append(" ");
sb.append("中");
sb.append("国");
System.out.println(sb.toString());

image-20240517160043570

1.3 java字节数组和字符串相互转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//1  字符串转字节数组
byte[] b = v4.getBytes(); // 默认utf8形式
System.out.println(b); // 输出对象形式,看不到字节数组
System.out.println(Arrays.toString(b));


// try {
// byte[] b1 = v4.getBytes("GBK"); // 'GBK'形式,需要捕获异常
// } catch (Exception e) {
//
// }
byte[] b1 = v4.getBytes("GBK"); // 'GBK'形式,需要捕获异常,或在方法上 throws Exception
System.out.println(Arrays.toString(b1));


// 2 字节数组转字符串
String v8 = new String(new byte[]{-27, -67, -83, -28, -70, -114, -26, -103, -113});
String v9 = new String(new byte[]{-59, -19, -45, -38, -22, -52},"GBK");
System.out.println(v8);
System.out.println(v9);

1.4 java 字符数组和字符串相互转换

1
2
3
4
5
6
7
8
9
10
// 1 字符数组转字符串
char[] c=new char[]{'彭','于','晏'};
String v1 = new String(c);
System.out.println(v1);

// 2 字符串串转字符数组
String str1 = "彭于晏";
char[] c=str1.toCharArray();
System.out.println(c.length);
System.out.println(c[0]);

1.5 python字节和字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
##### python中字符串与字节
v1 = '彭于晏'
v2 = v1.encode('utf-8')
print(v2) # b'\xe5\xbd\xad\xe4\xba\x8e\xe6\x99\x8f' 16进制表示
v3 = v1.encode('GBK')
print(v3) # b'\xc5\xed\xd3\xda\xea\xcc' 16进制表示

# 转换为10进制
v3 = [item for item in v2]
print(v3) # [229, 189, 173, 228, 186, 142, 230, 153, 143]

# 转换为二进制
v4 = [bin(item) for item in v2]
print(v4) # ['0b11100101', '0b10111101', '0b10101101', '0b11100100', '0b10111010', '0b10001110', '0b11100110', '0b10011001', '0b10001111']

# 转换为16进制
v5 = [hex(item) for item in v2]
print(v5) # ['0xe5', '0xbd', '0xad', '0xe4', '0xba', '0x8e', '0xe6', '0x99', '0x8f']

1.6 java字节数组转python字符串

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
# 字节有无符号
Python字节无符号(不含负数): 0 ~ 255
0 1 2 3 4 5 ... 127 128 129 130 ... 255

Java字节是有符号(含有负数):-128 ~ 127
0 1 2 3 4 5 ...127 -128 -127 - 126 -125 .... -2 -1

# python:彭于晏
[229, 189, 173, 228, 186, 142, 230, 153, 143]
# java:彭于晏
[-27, -67, -83, -28, -70, -114, -26, -103, -113]


### 编写一个java字节数组转换为python的字符串代码
逻辑是:数字大于0,不操作,小于0,加上256

v1 = [-27, -67, -83, -28, -70, -114, -26, -103, -113]
def java_arr_to_python_str(v1):
num_list = bytearray()
for i in v1:
if i < 0:
i = i + 256
num_list.append(i)
return num_list.decode('utf-8')


if __name__ == '__main__':
print(java_arr_to_python_str(v1))

二 Object类

Object类是java.lang包下的核心类,Object类是所有类的父类,何一个类时候如果没有明确的继承一个父类的话,那么它就是Object的子类

以下两种类的定义的最终效果是完全相同的

class Person { }

class Person extends Object { }

2.1 Object类可以接受所有类的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Demo05 {
public static void main(String[] args) {
String name="justin";
int age =19;
Object v1=name;
v1=age;
Person p=new Person();
v1=p;
System.out.println(v1);
// 定义Object类型数组
Object[] arrs=new Object[3];
arrs[0]="justin";
arrs[1]=19;
arrs[2]=p;
System.out.println(Arrays.toString(arrs));

}
}

class Person{
}

2.2 Object 类的方法

Object 类属于java.lang包,此包下的所有类在使用时无需手动导入,系统会在程序编译期间自动导入

image-20240517160101311

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
// 1. clone()
保护方法,实现对象的浅复制,只有实现了Cloneable接口才可以调用该方法,否则抛出CloneNotSupportedException异常。

// 2. getClass()
final方法,返回Class类型的对象,反射来获取对象。

//3. toString()
该方法用得比较多,一般子类都有覆盖,来获取对象的信息。

//4. finalize()
该方法用于释放资源。因为无法确定该方法什么时候被调用,很少使用。

//5. equals()
比较对象的内容是否相等

// 6. hashCode()
该方法用于哈希查找,重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。

// 7. wait()
wait方法就是使当前线程等待该对象的锁,当前线程必须是该对象的拥有者,也就是具有该对象的锁。wait()方法一直等待,直到获得锁或者被中断。wait(long timeout)设定一个超时间隔,如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态,直到以下事件发生。
其他线程调用了该对象的notify方法。
其他线程调用了该对象的notifyAll方法。
其他线程调用了interrupt中断该线程。
时间间隔到了。
此时该线程就可以被调度了,如果是被中断的话就抛出一个InterruptedException异常。

// 8. notify()
该方法唤醒在该对象上等待的某个线程。

//9. notifyAll()
该方法唤醒在该对象上等待的所有线程。


/* 常用的
getClass()
toString()
hashCode()
*/

2.3 获取Object类型变量的具体类型

1
2
3
4
5
6
7
8
9
10
11
// 通过getClass
Object v2=10;
System.out.println(v2.getClass());

// 通过判断确定类型
Object v2=10;
if (v2 instanceof Integer){
System.out.println("v2是Integer类型");
int i=(Integer) v2;
System.out.println(i);
}

三 容器类型之List

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

  • ArrayList,连续的内存地址的存储(底层基于数组,内部自动扩容) -> Python列表的特点
  • LinkedList,底层基于链表实现(底层基于链表) -> Python列表的特点

3.1 基本使用

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
import java.util.ArrayList;
import java.util.LinkedList;

public class Demo05 {
public static void main(String[] args) {
// ArrayList定义和使用
ArrayList ll=new ArrayList();
ll.add("justin");
ll.add(19);
ll.add(new Person());
System.out.println(ll);

//LinkedList定义和使用
LinkedList ll2=new LinkedList();
ll2.add("justin");
ll2.add(19);
ll2.add(new Person());
System.out.println(ll2);
// 他们都是List接口的实现


}
}

class Person{
}


// 他们都是List接口的实现,Java中的接口,是用来规定子类的行为

3.2 接口概念(了解)

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
import java.util.ArrayList;
import java.util.LinkedList;

interface Duck {
public void speak();

public void run();
}

/**
* 类实现接口,必须重写接口中所有方法
*/
class TDuck implements Duck {
@Override
public void speak() {

}

@Override
public void run() {

}
}

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


}
}


3.3 指定类型的List及常用操作

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
75
76
77
78
79
80
81
82
83
84
85
86
87
import java.util.ArrayList;
import java.util.LinkedList;


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

//***************** ArrayList 常用操作
// ArrayList<String> names = new ArrayList<String>();
// names.add("彭于晏");
// names.add("古天乐");
// names.add("杨颖");
//// names.add(19); //不能放数字
// names.add("刘亦菲");
// //1 根据索引取值
// String name = names.get(1);
// System.out.println(name);
//
// // 2 修改某个位置值
// names.set(1,"迪丽热巴");
// System.out.println(names);
//
// // 3 删除某个值
// names.remove("迪丽热巴");
// names.remove(0);
//
// // 4 大小
// System.out.println(names.size());
// // 5 是否包含
// System.out.println(names.contains("刘亦菲"));
//
// // 6 循环
// for (int i = 0; i < names.size(); i++) {
// System.out.println(names.get(i));
// }
//
// for (String item:names) {
// System.out.println(item);
//
// }


//***************** ArrayList 常用操作
LinkedList<String> names = new LinkedList<String>();
names.add("彭于晏");
names.add("古天乐");
names.add("杨颖");
// names.add(19); //不能放数字
names.add("刘亦菲");
//1 根据索引取值
String name = names.get(1);
System.out.println(name);

// 2 修改某个位置值
names.set(1,"迪丽热巴");
System.out.println(names);

// 3 删除某个值
names.remove("迪丽热巴");
names.remove(0);

// 4 大小
System.out.println(names.size());
// 5 是否包含
System.out.println(names.contains("刘亦菲"));

// 6 循环
for (int i = 0; i < names.size(); i++) {
System.out.println(names.get(i));
}

for (String item:names) {
System.out.println(item);

}

// 7 其他操作
names.push("xxx"); // 放在首位

names.addFirst("第一");
names.addLast("倒数第一");
System.out.println(names);
}
}



3.4 迭代

1
2
3
4
5
6
7
8
9
10
11
12
// 类似于python的迭代器

//ArrayList<String> names = new ArrayList<String>();
LinkedList<String> names = new LinkedList<String>();
names.add("彭于晏");
names.add("古天乐");
names.add("杨颖");
names.add("刘亦菲");
Iterator i =names.iterator();
while (i.hasNext()){
System.out.println(i.next());
}

四 容器类型之 Set

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

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

4.1 基本使用

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
import java.util.Arrays;
import java.util.HashSet;
import java.util.TreeSet;

public class Demo04 {
public static void main(String[] args) throws Exception {

// HashSet使用
// HashSet h= new HashSet();
// HashSet<String> h= new HashSet<String>();
// // 1 基本使用
// h.add("刘亦菲");
// h.add("刘亦菲");
// h.add("迪丽热巴");
// h.add("古天乐");
// h.add("彭于晏");
// h.add("Justin");
//
// System.out.println(h);
//
// // 2 判断值是否存在
// System.out.println(h.contains("迪丽热巴"));
//
// // 3 删除元素
// h.remove("刘亦菲");
// System.out.println(h);
// // 4 长度
// System.out.println(h.size());


// TreeSet使用,自动排序
TreeSet<String> h = new TreeSet<String>();
// TreeSet<String> h = new TreeSet<String>(){{add("刘亦菲");add("迪丽热巴");}};

// 1 基本使用
h.add("刘亦菲");
h.add("刘亦菲");
h.add("迪丽热巴");
h.add("古天乐");
h.add("彭于晏");
h.add("Justin");

System.out.println(h);

// 2 判断值是否存在
System.out.println(h.contains("迪丽热巴"));

// 3 删除元素
h.remove("刘亦菲");
System.out.println(h);
// 4 长度
System.out.println(h.size());


}
}

4.2 交并差集

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
import java.util.Arrays;
import java.util.HashSet;
import java.util.TreeSet;

public class Demo04 {
public static void main(String[] args) throws Exception {
HashSet<String> h1 = new HashSet<String>();
h1.add("古天乐");
h1.add("彭于晏");
h1.add("Justin");

HashSet<String> h2 = new HashSet<String>();
h2.add("古力娜扎");
h2.add("杨颖");
h2.add("迪丽热巴");
h2.add("刘亦菲");
h2.add("Justin");

HashSet<String> h3 = new HashSet<String>();
h3.addAll(h2); // 把h2的所有数据增加到h3中

System.out.println(h3);

h3.retainAll(h1); // 交集 & [Justin]
System.out.println(h3);

h2.addAll(h1); // 并集 | [杨颖, 迪丽热巴, 古力娜扎, 刘亦菲, Justin, 古天乐, 彭于晏]
System.out.println(h2);


h2.removeAll(h1); // 差集 [杨颖, 迪丽热巴, 古力娜扎, 刘亦菲]
System.out.println(h2);




}
}

4.3 循环取值和迭代

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.HashSet;
import java.util.Iterator;

public class Demo04 {
public static void main(String[] args) throws Exception {
HashSet<String> h1 = new HashSet<String>();
h1.add("古天乐");
h1.add("彭于晏");
h1.add("Justin");

// 循环
for (String item: h1) {
System.out.println(item);
}
//迭代
Iterator i=h1.iterator();
while (i.hasNext()){
System.out.println(i.next());
}
}
}

五 容器类型之Map

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

  • HashMap,无序。

  • TreeMap,默认根据key排序。(常用)

5.1 基本使用

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
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeMap;

public class Demo04 {
public static void main(String[] args) throws Exception {
// HashMap hm=new HashMap();
// hm.put("name","lqz");
// hm.put("age",19);
// hm.put("hobby","篮球");
// System.out.println(hm);

// HashMap<String,String> hm=new HashMap<String,String> ();
// hm.put("name","lqz");
// hm.put("age","19");
// hm.put("hobby","篮球");
// System.out.println(hm);


TreeMap<String,String> hm=new TreeMap<String,String> ();
hm.put("name","lqz");
hm.put("age","19");
hm.put("hobby","篮球");
System.out.println(hm);

}
}

5.2 常用操作

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
import java.util.*;

public class Demo04 {
public static void main(String[] args) throws Exception {
TreeMap<String,String> hm=new TreeMap<String,String> ();
hm.put("name","lqz");
hm.put("age","19");
hm.put("hobby","篮球");
System.out.println(hm);

// 1 移除元素
hm.remove("name");
System.out.println(hm);
// 2 大小
System.out.println(hm.size());

// 3 获取值
System.out.println(hm.get("name"));

//4 包含
System.out.println(hm.containsKey("name"));
System.out.println(hm.containsValue("篮球"));

//5 替换
hm.replace("age","99");
System.out.println(hm);

//6 循环 方式一 keySet
for (String key:hm.keySet()) {
System.out.println(hm.get(key));
}

// 循环方式 二 entrySet
for (Map.Entry<String,String> item:hm.entrySet()) {
System.out.println(item);
System.out.println(item.getKey());
System.out.println(item.getValue());

}

// 循环方式 三
Set s2 = hm.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();
System.out.println(k);
System.out.println(v);
}


}
}

六 面向对象

6.1 类与对象构造方法

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
public class Demo04 {
public static void main(String[] args) throws Exception {

Person p =new Person();
System.out.println(p);

Person p1=new Person("Justin",99);
System.out.println(p1);

}
}

class Person {
public String name;
public int age;

/**
* 构造方法一
*/
public Person() {
this.name = "justin";
this.age = 19;


}

/**
* 构造方法2
* @param name
* @param age
*/
public Person(String name, int age) {
this.name = name;
this.age = age;

}
}

6.1.1 方法重载

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
import java.util.*;

public class Demo04 {
public static void main(String[] args) throws Exception {

Person p =new Person();
System.out.println(p);

Person p1=new Person("Justin",99);
System.out.println(p1);


p.speak();
p.speak("说呀说");
}
}

class Person {
public String name;
public int age;

/**
* 构造方法一
*/
public Person() {
this.name = "justin";
this.age = 19;


}

/**
* 构造方法2
* @param name
* @param age
*/
public Person(String name, int age) {
this.name = name;
this.age = age;

}

/**
* speak方法,无参数
*/
public void speak(){
System.out.println("说哈");
}
/**
* speak方法,有参数,重载方法
*/
public void speak(String s){
System.out.println(s);
}
}

6.1.2 Hook重载的方法

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
/*
adb shell
su
cd /data/local/tmp/
./frida-server-16.0.19-android-arm64

端口转发
adb forward tcp:27042 tcp:27042
adb forward tcp:27043 tcp:27043
*/

import frida
import sys

# 连接手机设备
rdev = frida.get_remote_device()

session = rdev.attach("油联合伙人")

scr = """
Java.perform(function () {

// 包.类
var MessageDigest = Java.use("java.security.MessageDigest");

MessageDigest.update.overload('[B').implementation = function(data){
var res = this.update(data);
return res;
}

MessageDigest.update.overload('java.nio.ByteBuffer').implementation = function(data){
var res = this.update(data);
return res;
}

});
"""

script = session.create_script(scr)


def on_message(message, data):
print(message, data)


script.on("message", on_message)

script.load()
sys.stdin.read()

6.1.3 Hook构造方法

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
import frida
import sys

# 连接手机设备
rdev = frida.get_remote_device()

session = rdev.attach("油联合伙人")

scr = """
Java.perform(function () {

// 包.类
var StringBuilder = Java.use("java.lang.StringBuilder");

StringBuilder.$init.overload('int').implementation = function(num){
console.log(num);
if(num==32){
var res = this.$init(num);
}
return res;
}

});
"""

script = session.create_script(scr)


def on_message(message, data):
print(message, data)


script.on("message", on_message)

script.load()
sys.stdin.read()

6.2 静态成员(方法,变量)

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
public class Demo04 {
public static void main(String[] args) throws Exception {
Person p =new Person();
p.school="清华大学";
Person.school="北京大学";
System.out.println(p.school);
System.out.println(Person.school);

p.run();
Person.run();
}
}

class Person {
public static String school; // 静态变量,属于类
public String name;
public int age;

/**
* 构造方法一
*/
public Person() {
this.name = "justin";
this.age = 19;

}

public static void run(){
System.out.println("静态方法,走路,属于类");
}
}

6.3 继承

Java中的继承,只支持单继承,不支持多继承,但支持实现多个接口

6.3.1 java只支持单继承

1
2
3
4
5
6
class Base {
}
class Foo {
}
class Person extends Foo {
}

6.3.2 实现多个接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
interface Base{
public void speak();

}
interface Foo{
public void run();

}

class Person implements Base,Foo{

@Override
public void speak() {

}

@Override
public void run() {

}
}

__END__