1 python和java字符串比较
1.1 java字符串常用方法
import java.util.Arrays;
public class Demo01 {
public static void main(String[] args) {
// 1 字符串的常用方法
String origin = "hello world 中国";
//1 取指定位置的字符 从0 开始
// char v1=origin.charAt(13);
// System.out.println(v1);
// 2 循环打印出每个字符
// for (int i = 0; i < origin.length(); i++) {
// char item =origin.charAt(i);
// System.out.println(item);
// }
//3 取出前后空白
// String v2=origin.trim();
// System.out.println(v2);
// 4 转大写
System.out.println(origin.toUpperCase());
System.out.println(origin.toLowerCase());
// 5 分隔字符串 --->得到数组
String[] s = origin.split(" ");
System.out.println(s); // [Ljava.lang.String;@1b6d3586
System.out.println(Arrays.toString(s)); // [hello, world, 中国]
// 6 替换
String v2 = origin.replace('h', 'l');
// System.out.println(origin);
System.out.println(v2);
// 7 切片
String v3 = origin.substring(2, 6);
System.out.println(v3);
// 8 字符串相等
boolean b = origin.equals("hello world");
System.out.println(b);
// 9 包含 true
System.out.println(origin.contains("hello"));
// 10 以xx开头，以xx结尾
System.out.println(origin.startsWith("he"));
System.out.println(origin.endsWith("国"));
//11 末尾追加
String v5=origin.concat("justin");
System.out.println(v5);
// 12 如果后期反编译回来的代码，看到不会的方法，直接搜索即可
}
}
1.2 java字符串拼接
public class Demo02 {
public static void main(String[] args) {
// 1 字符串拼接--》反编译回来代码经常看到
// 方式一：直接相加,效率低，见得少
String s = "hello" + "hello" + "中国";
// 方式二 StringBuilder --->效率高，以后经常见
// StringBuilder sb=new StringBuilder(); // 类实例化得到对象
// sb.append("hello");
// sb.append(" ");
// sb.append("world");
// sb.append(" ");
// sb.append("中国");
// System.out.println(sb.toString());
// 方式三：StringBuffer 现成安全的
StringBuffer sb = new StringBuffer();
sb.append("hello");
sb.append(" ");
sb.append("world");
sb.append(" ");
sb.append("中国");
System.out.println(sb.toString());
}
}
1.3 java字节数组和字符串相互转换
import java.util.Arrays;
public class Demo03 {
public static void main(String[] args) {
// java字节数组和字符串相互转换
// 1 字符串转字节数组
String s = "彭于晏";
try {
// byte[] b = s.getBytes("GBK"); // 字符串转成字节数组，有编码格式---》等同于java对的 ''.encode('utf-8')
// byte[] b = s.getBytes("utf-8"); // 字符串转成字节数组，有编码格式---》等同于java对的 ''.encode('utf-8')
byte[] b = s.getBytes();
System.out.println(b); //[B@1b6d3586
System.out.println(Arrays.toString(b)); //[-27, -67, -83, -28, -70, -114, -26, -103, -113]
} catch (Exception e) {
}
// 2 字节数组转字符串
// byte [] b1= new byte[4]; // 空的，没有数据
byte [] b1= new byte[]{-27, -67, -83, -28, -70, -114, -26, -103, -113}; // 定于并赋初值
System.out.println(Arrays.toString(b1));
// 转成字符串
String name =new String(b1);
System.out.println(name);
}
}
1.4 java字符数组和字符串相互转换
public class Demo04 {
public static void main(String[] args) {
// 字符数组和字符串相互转换
// 字符： a ? ! 中 国
// 1 字符串转成字符数组
String name = "彭于晏";
char[] c = name.toCharArray();
System.out.println(c); // c 是 数组，不是字符串，虽然显示成字符串的样子 ['彭' '于' '晏']
//数组可以按索引取值
System.out.println(c[0]); // 数组才行
// System.out.println(name[0]); // python 可以， java不能按下标取值
// 2 字符数组转字符串
// char[] c1=new char[5]; // 数组定义，必须有大小，必须写个数字 空的
char[] c1 = new char[]{'彭', '于', '盐'}; // 定义同时，赋初值
String name1 =new String(c1);
System.out.println(name1);
// 3 定义一个数组，长度是 5 ，后期大于5 ，不行 数组定义后，长度不能变化
// char[] c1 = new char[]{'彭', '于', '盐'};
System.out.println(c1[2]);
}
}
1.5 python的字节和字符串
name = '彭于晏'
s = name.encode('utf-8')
print(s) # \xe5\xbd\xad\xe4\xba\x8e\xe6\x99\x8f # [-27, -67, -83, -28, -70, -114, -26, -103, -113]
#十进制展示形式
l = []
for item in s:
l.append(item)
print(l) # [229, 189, 173, 228, 186, 142, 230, 153, 143]
# 二进制展示形式
l2 = []
for item in s:
l2.append(bin(item))
print(l2)
# 16 进制展示形式
l3 = []
for item in s:
l3.append(hex(item))
print(l3)
1.6 java字节数组转成python的字符串(重要)
# java 彭于晏字节数组：[-27, -67, -83, -28, -70, -114, -26, -103, -113]
# pyton中的字节数组： [229, 189, 173, 228, 186, 142, 230, 153, 143]
# java 有符号 有正负
0 1 2 3 4 ... 127 -128 -127 -126 ... -1
# python 无符号，只有正
0 1 2 3 4 ... 127 128 129 ............255
# 要把java的字节数组转成python的字符串形式
# 反编译hook到这种东西：[-27, -67, -83, -28, -70, -114, -26, -103, -113] 使用python转成字符串
def java_arr_to_python_str(v1):
num_list=bytearray()
for i in v1: #小于0的加256，大于0的不管了
if i < 0:
i = i + 256
num_list.append(i)
return num_list.decode('utf-8')
if __name__ == '__main__':
v1 = [-27, -67, -83, -28, -70, -114, -26, -103, -113]
print(java_arr_to_python_str(v1)) # [229, 189, 173, 228, 186, 142, 230, 153, 143]
2 java 的Object类
# java 中定义变量，必须要指定变量类型
# 变量类型后期不能改变
String name ="justin";
name=19 # 报错
String [] names=new String[]{"lqz","justin"};
# 有个变量 即想是字符串类型，又想是int类型---》Object类的对象
# Object是所有类的父类---》所以它的对象可以代指所有类型
2.1 可以接受任意类型
public class Demo05 {
public static void main(String[] args) {
// Object 类
// 1 可以接受任意类型
String name ="justin";
name=99; // 错的
Object o1="lqz";
o1=99;
Person p =new Person(); //p是Person类的对象
o1=p;
}
}
class Person{
}
2.2 Object 类的方法
// 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() System.out.println(p) 打印它的返回值
equals() 比较两个对象是否相等 "lqz".equals("lqz")
*/
2.3 获取Object对象的具体类型
// 3 获取Object对象的具体类型
Object o1="lqz"; // o1 本质是个字符串 ，表面上看只能看到它是Object类型的对象
System.out.println(o1.getClass()); // class java.lang.String
// o1=999;
System.out.println(o1.getClass()); // class java.lang.Integer
Person p =new Person();
// o1=p;
System.out.println(o1.getClass()); // class Person
// 虽然Object 可以接收所有类型，但是他有具体类型
// Object 相当于自然界中的动物这一类： 狗，人，猫 但我们有具体类型
// 想把它转回真正的自己的类型
if(o1 instanceof Person){
System.out.println("我是人类型");
} else if (o1 instanceof Integer) {
System.out.println("是数字");
} else if (o1 instanceof String) {
System.out.println("是字符串");
}
3 容器类型之List
# 容器类型：放多个元素，之前学过数组可以放多个元素，但是数组固定长度，不能改变，追加，删除值都不行
# List---》类似于python中的列表--》用起来基本一致，只是底层数据结构不一样--》对数据的增删查改的时间和空间复杂度不一样
-ArrayList：底层是基于数组的
-LinkedList：底层是基于链表的
3.1 基本使用
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Objects;
public class Demo06 {
public static void main(String[] args) {
// 1 List 类型之 ArrayList：底层是基于数组的
// 定义一个ArrayList--->现在里面是空的
// ArrayList ll = new ArrayList();
// ArrayList<Object> ll = new ArrayList<Object>(); // 等同于上面
// 往里追加值 ---->默认情况下，可以放任意类型---》可以放 Object类型 的对象
// ll.add("justin");
// ll.add(99);
//ArrayList<String> ll1 = new ArrayList<String>();
//ll1.add("张三");
//ll1.add(1); // 只能放字符串类型
// List 类型之LinkedList：底层是基于链表的
// LinkedList<Object> ll = new LinkedList<Object>();
// ll.add("justin");
// ll.add(99);
// System.out.println(ll);
LinkedList<String> ll1 = new LinkedList<String>();
ll1.add("justin");
// ll1.add(99); // 不能放数字类型
System.out.println(ll1);
}
}
3.1 List的常用操作（常用方法）
// 3 ArrayList 常用方法
// ArrayList<String > ll2=new ArrayList<String>();
// // 3.1 追加值
// ll2.add("justin");
// ll2.add("zs");
// // 3.2 根据索引取值 从0开始
// System.out.println(ll2.get(1));
//
// // 3.3 修改某个位置值
// ll2.set(0,"彭于晏");
// System.out.println(ll2);
//
// // 3.4 删除某个值
// //ll2.remove("zs");
//// ll2.remove(1);
// System.out.println(ll2);
//
//
//// ArrayList<Integer > ll3=new ArrayList<Integer>();
//// ll3.add(1);
//// ll3.add(2);
//// ll3.add(3);
//// ll3.remove(3);
//
// // 3.5 大小
// System.out.println(ll2.size());
//
// // 3.6 是否包含
// System.out.println(ll2.contains("彭于晏"));
//
// // 3.7 循环
// // 基于索引的循环---》python 没有这种方式
// for (int i = 0; i < ll2.size(); i++) {
// System.out.println(ll2.get(i));
// }
// // 基于迭代的循环---》python 的 xx in xxx
// for (String name:ll2) {
// System.out.println(name);
// }
// 4 LinkedList 常用方法
LinkedList<String > ll2=new LinkedList<String>();
// 3.1 追加值
ll2.add("justin");
ll2.add("zs");
// 3.2 根据索引取值 从0开始
System.out.println(ll2.get(1));
// 3.3 修改某个位置值
ll2.set(0,"彭于晏");
System.out.println(ll2);
// 3.4 删除某个值
//ll2.remove("zs");
// ll2.remove(1);
System.out.println(ll2);
// ArrayList<Integer > ll3=new ArrayList<Integer>();
// ll3.add(1);
// ll3.add(2);
// ll3.add(3);
// ll3.remove(3);
// 3.5 大小
System.out.println(ll2.size());
// 3.6 是否包含
System.out.println(ll2.contains("彭于晏"));
// 3.7 循环
// 基于索引的循环---》python 没有这种方式
for (int i = 0; i < ll2.size(); i++) {
System.out.println(ll2.get(i));
}
// 基于迭代的循环---》python 的 xx in xxx
for (String name:ll2) {
System.out.println(name);
}
//3.8 多的方法
ll2.push("第一位"); // 向第一个位置放值
ll2.addFirst("真第一位");
ll2.addLast("最后");
System.out.println(ll2);
4 容器类中之Set
# 集合类型
# HashSet：去重，无序
# TreeSet：去重，有序
4.1 基本使用
//HashSet h=new HashSet(); // 如果不写，可以放任意类型
HashSet<String> h=new HashSet<String>();
h.add("刘亦菲");
h.add("justin");
h.add("彭于晏");
h.add("迪丽热巴");
h.add("lqz");
h.add("lqz");
System.out.println(h); // 没有顺序
TreeSet<String> h1=new TreeSet<String>();
h1.add("刘亦菲");
h1.add("justin");
h1.add("彭于晏");
h1.add("迪丽热巴");
h1.add("lqz");
h1.add("lqz");
System.out.println(h1); //
4.2 交差并
// 1 交集
//h.retainAll(h1);
//System.out.println(h);
// 2 并集
h.addAll(h1);
System.out.println(h);
// 3 差集
h.removeAll(h1);
System.out.println(h);
4.3 迭代取值
// 3 迭代取值
HashSet<String> h2 = new HashSet<String>();
h2.add("刘亦菲");
h2.add("justin");
h2.add("彭于晏");
h2.add("迪丽热巴");
h2.add("lqz");
// for循环
for (String name: h2) {
System.out.println(name);
}
System.out.println("============");
Iterator i =h2.iterator(); // 可迭代对象 .__iter__方法 对象.__next__
while (i.hasNext()){
System.out.println(i.next());
}
5 容器类型之Map
# 类似于python字典类型
# Map类型，放key:value 数据结构
-HashMap：无序
-TreeMap：有序
5.1 基本使用
//HashMap hm =new HashMap(); // 可以放Object
//hm.put("name","justin");
//hm.put(1,99);
HashMap<String, String> hm = new HashMap<String, String>(); // 指定key value类型
hm.put("name", "justin");
hm.put("age", "19");
hm.put("hobby", "篮球");
System.out.println(hm);
TreeMap<String, String> tm = new TreeMap<String, String>(); // 指定key value类型
tm.put("name", "justin");
tm.put("age", "19");
tm.put("hobby", "篮球");
System.out.println(tm);
5.2 常用方法
// 2 常用操作
//移除元素
tm.remove("name");
System.out.println(tm);
// 大小
System.out.println(tm.size());
// 获取值
System.out.println(tm.get("hobby"));
// 包含
System.out.println(tm.containsKey("hobby"));
System.out.println(tm.containsValue("19"));
// 替换
hm.replace("age","199");
System.out.println(hm);
5.3 循环
// 循环方式一 按key循环
for (String key : hm.keySet()) {
System.out.printf("key是：%s--", key);
System.out.printf("value是：%s\n", hm.get(key));
}
// 循环方式二：按key和value循环
for (Map.Entry<String, String> item : hm.entrySet()) {
System.out.printf("key是：%s--", item.getKey());
System.out.printf("value是：%s\n", item.getValue());
}
// 方式三：while循环
Set s2=hm.entrySet();
Iterator ite2=s2.iterator();
while (ite2.hasNext()){
Map.Entry item=(Map.Entry)ite2.next();
System.out.printf("key是：%s--", item.getKey());
System.out.printf("value是：%s\n", item.getValue());
}
6 Java面向对象
6.1 类与对象和构造方法
public class Demo09 {
public static void main(String[] args) {
// 类与对象--->跟py很像
//Dog dog =new Dog();
// 构造方法---》python---》__init__
Dog dog =new Dog("小奶狗",2); // 必须要在类中写构造方法,触发构造方法
System.out.println(dog.name);
Dog dog1 =new Dog("小野狗",2);
System.out.println(dog1.name);
// 传几个参数，默认就用哪个
Dog dog2 =new Dog("小黑狗");
System.out.println(dog2.name);
System.out.println(dog2.age);
Dog dog3 =new Dog();
System.out.println(dog3.name);
}
}
// 定义Dog类
class Dog{
public String name;
public int age;
// 构造方法--》初始化方法--》python的 __init__
// 必须是public，没有返回值，也不需要写返回值类型，必须跟类同名，可以有参数
// 构造函数可以有多个
public Dog(String name,int age){
// 把传入的，赋值给变量---》使用this关键字--》等同于pyton的self
this.name=name;
this.age=age;
}
public Dog(String name){
this.name=name;
}
public Dog(){
}
}
6.2 静态成员(方法，变量)
public class Demo10 {
public static void main(String[] args) {
// 静态成员
Student.school = "北大";
Student s = new Student("justin", 19);
System.out.println(s.name);
System.out.println(s.age);
s.school = "xxx"; // 跟py不一样
System.out.println(s.school); // school 不属于对象，但是能拿到，如果改了，所有都会被改
System.out.println(Student.school);
Student s2 = new Student("彭于晏", 19);
System.out.println(s2.school);
System.out.println(Student.school);
// 静态方法，类的方法 对象和类都可以用
s2.speak();
Student.speak();
}
}
class Student {
// 给类用的
public static String school = "清华";
// 对象属性--》给对象用的
public String name;
public int age;
public Student(String name, int age) {
// this 代指对象，不能拿到school，因为它是类的
this.name = name;
this.age = age;
}
// 类的方法，类来调用，所以里面没有this
public static void speak() {
System.out.println("人说话了");
// System.out.println(this.name); //类来调用，没有对象
}
}
6.3 继承
public class Demo11 {
public static void main(String[] args) {
// 继承：java只支持单继承 python支持多继承
Cat c = new Cat();
c.Speak();
c.Speak("小野猫");
}
}
class Animal {
public void Speak() {
System.out.println("动物说话");
}
}
// java 只能单继承，只能继承一个类
class Cat extends Animal{
// 重写方法：重写父类的方法,返回值，参数，名字必须一致
public void Speak() {
System.out.println("猫叫");
}
// 重要重要重要： 重载
// 重写和重载
// 重写是重写父类方法，名字和参数和返回值必须一致，必须有继承关系
// 重载：方法名相同，参数不同，就是重载，不需要有继承关系，就叫重载方法
public void Speak(String name) {
System.out.println("重载猫叫");
System.out.println(name);
}
}