微风qin
微风qin

JavaSE-part1

文章目录

  • Day01 面向对象特性
    • 1.java继承注意点
    • 2.多态
        • 2.1多态概述
        • 2.2多态中成员的特点:star::star:
        • 2.3多态的转型:star::star:
    • 3.Super
    • 4.方法重写:star::star:
    • 5.Object类:star::star:
  • Day02 面向对象特性
    • 1.代码块:star:(主要是初始化变量，先于构造器)
    • 2.单例设计模式:star::star:
    • 3.Final
    • 4.抽象类:star:
    • 5.接口:star::star:
    • 6.内部类:star::star:
      • 6.1局部内部类
      • 6.2匿名内部类:star::star:
      • 6.3成员内部类
      • 6.4静态内部类
    • 7.类加载顺序:star::star:
  • Day03 枚举类 注解 异常
    • 1.枚举类
      • 1.1自定义枚举类
      • 1.2enum关键字枚举类
    • 2.注解
      • 2.1元注解
    • 3.异常:star::star:
      • 3.1异常描述
      • 3.2异常分类
      • 3.3异常处理（捕获异常,处理异常,使程序能够正常执行下去）:star:
        • 3.3.1try - catch-finally
        • 3.3.2throws
        • 3.3.3手动抛出异常
        • 3.3.4用户自定义异常类
  • Day04 常用类
    • 1.常用类:star::star::star:
      • 1.1包装类
      • 1.2String
        • 1.2.1构造器
        • 1.2.2存储位置（区分字符串常量和string对象）
        • 1.2.3常用方法
        • 1.2.4相关转换
      • 1.3StringBuffer类（可变字符串）
        • 1.3.1构造器（缓存区）
        • 1.3.2常用方法
      • 1.4StringBuilder类
        • 1.4.1==区别==
      • 1.5Date
          • 1.5.1java8之前
          • 1.5.2java8:star:
      • 1.6Java比较器:star::star::star:
      • 1.7System类
  • Day05 集合
    • 1.集合:star::star::star:
      • 1.1两大分类(collection和map)
      • 1.2Colltection
        • 1.2.1方法
      • 1.3iterator迭代器
      • 1.4List接口
        • 1.4.1方法
        • 实现类
        • 1.4.2**ArrayList**
        • **1.4.3LinkedList**
        • **1.4.4Vector**
      • 1.5Set接口(无索引)
        • 1.5.1==**HashSet**==
        • 1.5.2==**LinkedHashSet**==（适合遍历，遍历效率高）
        • 1.5.3==**TreeSet**(同一对象，定制排序)==
      • 1.6Map接口
        • 1.6.1概述
        • 1.6.2底层实现原理
        • 1.6.3常用方法
        • 1.6.4HashMap
        • 1.6.5==对理解key以Set存储很重要==
        • 1.6.6重点
        • 1.6.7LinkHashMap
        • 1.6.8TreeMap
        • 1.6.9Properties
      • 1.7Collections工具类（如数组有Arrays工具类）
      • 总结
  • Day06 泛型
    • 1.泛型(只在编译期有效，运行时被擦除)
        • 1.1基础概念
        • 1.2基本使用
        • 1.3自定义泛型类:star::star::star:
        • 1.4特性
        • 1.5泛型类
        • 1.6泛型接口
        • 1.7泛型方法
        • 1.8泛型的继承和通配符:star::star::star:
        • 1.7泛型方法
        • 1.8泛型的继承和通配符:star::star::star:

Day01 面向对象特性

JavaSE-part1_第1张图片

JavaSE-part1_第2张图片

访问级别 访问修饰符 同类 同包 子类 不同包
公开 public ✅ ✅ ✅ ✅
受保护 protected ✅ ✅ ✅ ❌
默认 无 ✅ ✅ ❌ ❌
私有 private ✅ ❌ ❌ ❌

JavaSE-part1_第3张图片

1.java继承注意点

JavaSE-part1_第4张图片

public class ExtendDemo {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show();
    }
}
class Fu{
    int num = 10;
    int numFu = 100;
    public void method(){
        System.out.println("父类method");
    }
}

class Zi extends Fu{
    int num = 20;
    int numZi = 200;

    public void method(){
        System.out.println("子类method");
    }

    public void show(){
        int num = 30;
        System.out.println("局部变量num:"+num);// 30
        System.out.println("本类成员变量num:"+this.num);// 20
        System.out.println("父类成员变量num:"+super.num);// 10
        // 访问本类的method方法
        this.method();// 子类method
        // 访问父类的method方法
        super.method();// 父类method
    }
}
//局部变量num:30
//本类成员变量num:20
//父类成员变量num:10
//子类method
//父类method

JavaSE-part1_第5张图片

类在继承时，先创建父类空间，然后再创建子类空间

这张图执行顺序：

 * 先在方法区加载类的信息，方法区为类中的方法分配空间和地址。
 * 然后main方法进栈，然后new对象，先创建父类空间，再创建子类空间，并为其变量分配空间

值得注意的是，父类和子类重名的变量和方法没有被覆盖，而是独自存在。

new子类对象，想访问父类的重名的public变量和方法，通过super.的方式访问

图中未画出给Object类分配的空间

2.多态

2.1多态概述

  • 方法和对象具有多种形态
  • 父类的引用指向子类的对象
  • 父类类型 变量名=new 子类类型();
  • 多态是同一个行为具有多个不同表现形式或形态的能力。
  • 多态就是同一个接口，使用不同的实例而执行不同操作。

2.2多态中成员的特点⭐️⭐️

  1. 多态成员变量：编译运行看左边

    Fu f=new Zi();

    System.out.println(f.num);//f是Fu中的值，只能取到父中的值

  2. 多态成员方法：编译看左边，运行看右边

    这里主要由于方法的动态绑定机制

​ Fu f1=new Zi();

​ 3.属性没有重写之说，属性编译的时候看类型

​ System.out.println(f1.show());//f1的门面类型是Fu,但实际类型是Zi,所以调用的是重写后的方法。

2.3多态的转型⭐️⭐️

  • 向上转型：多态本身就是向上转型过的过程

​ 使用格式：父类类型 变量名=new 子类类型();

​ 适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。

  • **向下转型：**一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型

​ 使用格式：子类类型 变量名=（子类类型） 父类类型的变量；

​ 适用场景：当要使用子类特有功能时。

  • eg1
package day0524;
 
public class demo04 {
    public static void main(String[] args) {
        People p=new Stu();
        p.eat();
        //调用特有的方法
        Stu s=(Stu)p;
        s.study();
        //((Stu) p).study();
    }
}
class People{
    public void eat(){
        System.out.println("吃饭");
    }
}
class Stu extends People{
    @Override
    public void eat(){
        System.out.println("吃水煮肉片");
    }
    public void study(){
        System.out.println("好好学习");
    }
}
class Teachers extends People{
    @Override
    public void eat(){
        System.out.println("吃樱桃");
    }
    public void teach(){
        System.out.println("认真授课");
    }
}
  • eg2
public class duotai {
    public static void main(String[] args) {
        //因为aa实际上还是BB类型的，现在只是属性和类型限定为AA，运行时还有BB的特征
        AA aa = new BB();
        System.out.println(aa instanceof AA);//true
        System.out.println(aa instanceof BB);//true
    }
}
class AA{
}
class BB extends AA{
}

3.Super

JavaSE-part1_第6张图片

4.方法重写⭐️⭐️

  1. 子类的方法的形参列表,方法名称，要和父类方法的形参列表,方法名称完全一样

  2. 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类 返回相等或从小原则

  3. 子类方法大于等于父类方法的访问权限

5.Object类⭐️⭐️

==

a 既可以判断基本类型，又可以判断引用类型

b 如果判断基本类型，判断的是值是否相等

c 如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象

	public void test01(){
        int[] a = new int[10];
        int[] b = a;
        System.out.println(a == b);//true
        //String类节省内存的方法
        String c = "abc";
        String d = "abc";
        System.out.println(c == d);//true 常量区的特性
        int[] e = new int[10];
        int[] f = new int[10];
        System.out.println(e == f);//false
    }

equals

a.equals:是Object类中的方法，只能判断引用类型

b.默认判断的是地址是否相等，子类中**往往重写该方法**，用于判断内容是否相等

JavaSE-part1_第7张图片

public void test02(){
        //equals
        String a = "abc";
        String b = "abc";
        String c = "abcd";
        System.out.println(a.equals(b));//true
        System.out.println(a.equals(c));//false
        int e = 10;
        int f = 10;
        //e.equals(f) xxx
    }

hashcode

a.提高具有哈希结构的容器的效率
b.两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
c.两个引用，如果指向的是不同对象，则哈希值是不一样的
d.哈希值主要根据地址号来的，不能完全将哈希值等价子地址
e.后面在集合中hashCode 如果需要的话，也会重写

​ f.两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals(java.lang.Object) 方法，只能够说明这两个对象在散列存储结构中，如Hashtable，他们**“存放在同一个篮子里”**。

public class HashTest {
	private int i;
 
	public int getI() {
		return i;
	}
 
	public void setI(int i) {
		this.i = i;
	}
 
	public int hashCode() {
		return i % 10;
	}
 
	public final static void main(String[] args) {
		HashTest a = new HashTest();
		HashTest b = new HashTest();
		a.setI(1);
		b.setI(1);
		Set<HashTest> set = new HashSet<HashTest>();
		set.add(a);
		set.add(b);
		System.out.println(a.hashCode() == b.hashCode());//true
		System.out.println(a.equals(b));//flase
		System.out.println(set);//[oopBase.HashTest@1, oopBase.HashTest@1]
	}
}

public void test03(){
        //hashcode
        int a[] = new int[10];
        int b[] = new int[10];
        int c[] = a;
        System.out.println(a);//[I@5e5d171f
        System.out.println(b);//[I@24313fcc
        System.out.println(c);//[I@5e5d171f
        System.out.println(a.hashCode() == b.hashCode());//true
        System.out.println(a.hashCode() == c.hashCode());//false
    }

tostring

a.默认返回：全类名＋@+哈希值的十六进制
b.子类往往重写to String方法，用于返回对象的属性信息
c.重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式
d.当直接输出一个对象时，toString 方法会被默认的调用

public void test04(){
        //toString
        String a = "abc";
        int[] b = new int[10];
        System.out.println(a.toString());//abc
        System.out.println(b.toString());//[I@24313fcc
    }

finalize

a.当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作
b.什么时候被回收：当**某个对象没有任何引用时，**则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁 该对象前，会先调用finalize方法
c.垃圾回收机制的调用，是由系统来決定(即有自己的GC算法)，也可以通过System.gc() 主动触发垃圾回收机制

Day02 面向对象特性

1.代码块⭐️(主要是初始化变量，先于构造器)

image-20221219202546567

JavaSE-part1_第8张图片

JavaSE-part1_第9张图片

JavaSE-part1_第10张图片

2.单例设计模式⭐️⭐️

JavaSE-part1_第11张图片

JavaSE-part1_第12张图片

image-20221219203325714

public class Test {
    public static void main(String[] args) {
        GirlFriend1 girlFriend1 = GirlFriend1.getGirlFriend();
        System.out.println(girlFriend1.getName());
        GirlFriend2 girlFriend2 = GirlFriend2.getInstance();
        System.out.println(girlFriend2.getName());
    }
}
//饿汉式
class GirlFriend1{
    private String name;
    private GirlFriend1(){
        this.name = "小冰";
    }
    public String getName(){
        return this.name;
    }
    public static GirlFriend1 girlFriend1 = new GirlFriend1();
    public static GirlFriend1 getGirlFriend(){return girlFriend1;}
}
//懒汉式
class GirlFriend2{
    private String name;
    private static GirlFriend2 girlFriend2 = null;//
    private GirlFriend2(){
        this.name = "小娜";
    }
    public String getName(){
        return this.name;
    }
    public static GirlFriend2 getInstance(){
        if(girlFriend2 == null){
            return new GirlFriend2();
        }
        return girlFriend2;
    }
}

JavaSE-part1_第13张图片

JavaSE-part1_第14张图片

3.Final

JavaSE-part1_第15张图片

4.抽象类⭐️

JavaSE-part1_第16张图片

public class Test {
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        a.cal();
        b.cal();
    }
}
abstract class Template{
    public abstract void job();
    public void cal(){
        long start = System.currentTimeMillis();
        job();
        long end = System.currentTimeMillis();
        System.out.println("时间" + (end - start));
    }
}
class A extends Template{

    @Override
    public void job() {
        long num = 0;
        for (long i = 0; i < 100000000; i++) {
            num += i;
        }
    }
}
class B extends Template{

    @Override
    public void job() {
        long num = 0;
        for (long i = 0; i < 100000000; i++) {
            num *= i;
        }
    }
}

JavaSE-part1_第17张图片

JavaSE-part1_第18张图片

5.接口⭐️⭐️

JavaSE-part1_第19张图片

JavaSE-part1_第20张图片

JavaSE-part1_第21张图片

//接口也相当于一个类但是不能实例化
//接口比抽象类更能提供一般的方法
public class Test2 {
    public static void main(String[] args) {
        USB[] usbs = new USB[2];//引用数组
        usbs[0] = new Phone();
        usbs[1] = new Camera();
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work();
            if(usbs[i] instanceof Phone){
                ((Phone)usbs[i]).cal();
            }
        }
    }
}
class Phone implements USB{
    @Override
    public void work() {
        System.out.println("手机使用中");
    }
    public void cal(){
        System.out.println("手机可以打电话");
    }
}
class Camera implements USB{
    @Override
    public void work() {
        System.out.println("相机使用中");
    }
    public void cal(){
        System.out.println("相机可以照相");
    }
}

JavaSE-part1_第22张图片

JavaSE-part1_第23张图片

JavaSE-part1_第24张图片

JavaSE-part1_第25张图片

package com.atguigu.java;

public class StaticProxyTest {

	public static void main(String[] args) {
		Star s = new Proxy(new RealStar());
		s.confer();
		s.signContract();
		s.bookTicket();
		s.sing();
		s.collectMoney();
	}
}

interface Star {
	void confer();// 面谈

	void signContract();// 签合同

	void bookTicket();// 订票

	void sing();// 唱歌

	void collectMoney();// 收钱
}

class RealStar implements Star {

	public void confer() {
	}

	public void signContract() {
	}

	public void bookTicket() {
	}

	public void sing() {
		System.out.println("明星：歌唱~~~");
	}

	public void collectMoney() {
	}
}

class Proxy implements Star {///代理类和被代理类实现同一套接口，帮被代理类去做事情，最后再加上被代理类的/独有的事情
	private Star real;

	public Proxy(Star real) {关键
		this.real = real;
	}

	public void confer() {
		System.out.println("经纪人面谈");
	}

	public void signContract() {
		System.out.println("经纪人签合同");
	}

	public void bookTicket() {
		System.out.println("经纪人订票");
	}

	public void sing() {
		real.sing();
	}

	public void collectMoney() {
		System.out.println("经纪人收钱");
	}
}

JavaSE-part1_第26张图片

JavaSE-part1_第27张图片

public class Test5 {
    public static void main(String[] args) {
        Man man = new Man();
        man.help();
    }
}
interface Filial {// 孝顺的
    default void help() {
        System.out.println("老妈，我来救你了");
    }
}
interface Spoony {// 痴情的
    default void help() {
        System.out.println("媳妇，别怕，我来了");
    }
}
class Man implements Filial, Spoony {
    @Override
    public void help() {
        System.out.println("我该怎么办呢？");
        Filial.super.help();
        Spoony.super.help();
    }
}

JavaSE-part1_第28张图片

6.内部类⭐️⭐️

JavaSE-part1_第29张图片

JavaSE-part1_第30张图片

JavaSE-part1_第31张图片

JavaSE-part1_第32张图片

6.1局部内部类

JavaSE-part1_第33张图片

JavaSE-part1_第34张图片

JavaSE-part1_第35张图片

6.2匿名内部类⭐️⭐️

JavaSE-part1_第36张图片

image-20221219211902197

JavaSE-part1_第37张图片

JavaSE-part1_第38张图片

JavaSE-part1_第39张图片

6.3成员内部类

这个创建内部类的对象时，一定要先创建外部类的对象，这样才能继续创建内部类的对象

JavaSE-part1_第40张图片

JavaSE-part1_第41张图片

JavaSE-part1_第42张图片

6.4静态内部类

JavaSE-part1_第43张图片

JavaSE-part1_第44张图片

7.类加载顺序⭐️⭐️

JavaSE-part1_第45张图片

package com.atguigu.java1;

class Father {
	static {
		System.out.println("11111111111");
	}
	{
		System.out.println("22222222222");
	}

	public Father() {
		System.out.println("33333333333");

	}

}

public class Son extends Father {
	static {
		System.out.println("44444444444");
	}
	{
		System.out.println("55555555555");
	}
	public Son() {
		System.out.println("66666666666");
	}


	public static void main(String[] args) { // 由父及子 静态先行
		System.out.println("77777777777");
		System.out.println("************************");
		new Son();
		System.out.println("************************");

		new Son();
		System.out.println("************************");
		new Father();
	}
	// 11111111111 //加载类信息的时候执行静态代码块
	// 44444444444
	// 77777777777
	// ************************
	// 22222222222
	// 33333333333
	// 55555555555
	// 66666666666
	// ************************
	// 22222222222
	// 33333333333
	// 55555555555
	// 66666666666
	// ************************
	// 22222222222
	// 33333333333

}

Day03 枚举类 注解 异常

1.枚举类

1.1自定义枚举类

image-20221221144625789

public class Test1 {
    public static void main(String[] args) {
        A spring = A.SPRING;
        System.out.println(spring.getDesc());
        A winter = A.WINTER;
        System.out.println(winter.getDesc());
    }
}
/*
    自定义枚举类
 */
class A{
    private String name;
    private String desc;

    private A(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    
    //这里SPRING直接属于A类，直接获取对象
    //单例模式饿汉式中也属于A类，但是权限是私有的，只能调用公开的方法获取对象
    public static final A SPRING = new A("春天","春暖花开");
    public static final A WINTER = new A("冬天","寒冷");

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }
}

1.2enum关键字枚举类

JavaSE-part1_第46张图片

JavaSE-part1_第47张图片

JavaSE-part1_第48张图片

JavaSE-part1_第49张图片

JavaSE-part1_第50张图片

public class Test2 {
    public static void main(String[] args) {
        //1.Enum类name方法
        Season spring = Season.SPRING;
        System.out.println(spring.name());//SPRING
        //2.Enum类中ordinal方法，看所属的常量排在第几位
        System.out.println(spring.ordinal());//0
        //3.Enum中values静态方法，得到所有的枚举对象的值
        //4.Enum中toString方法已经重写
        Season[] seasons = Season.values();
        for(Season season : seasons){
            System.out.println(season);//SPRING WINTER
        }
        //5.Enum类的静态方法valueOf方法,内部为变量名
        Season spring1 = Season.valueOf("SPRING");
        System.out.println(spring1);//SPRING
        //比较枚举常量，比较的是编号
        System.out.println(spring1.compareTo(spring));//0
    }
}
enum Season{
    SPRING("春天","春暖花开"),WINTER("冬天","寒冷");
    private String name;
    private String desc;

    Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
}

image-20221221151849490

2.注解

JavaSE-part1_第51张图片

JavaSE-part1_第52张图片

JavaSE-part1_第53张图片

JavaSE-part1_第54张图片

JavaSE-part1_第55张图片

JavaSE-part1_第56张图片

JavaSE-part1_第57张图片

JavaSE-part1_第58张图片

JavaSE-part1_第59张图片

JavaSE-part1_第60张图片

JavaSE-part1_第61张图片

JavaSE-part1_第62张图片

2.1元注解

JavaSE-part1_第63张图片

JavaSE-part1_第64张图片

JavaSE-part1_第65张图片

JavaSE-part1_第66张图片

JavaSE-part1_第67张图片

JavaSE-part1_第68张图片

JavaSE-part1_第69张图片

JavaSE-part1_第70张图片

JavaSE-part1_第71张图片

3.异常⭐️⭐️

3.1异常描述

JavaSE-part1_第72张图片

JavaSE-part1_第73张图片

3.2异常分类

运行时异常，编译期没有错误，异常只有在在运行阶段才体现出体现出来

编译时异常，必须处理，否则程序通不过编译阶段，更谈不上运行

JavaSE-part1_第74张图片

JavaSE-part1_第75张图片

JavaSE-part1_第76张图片

JavaSE-part1_第77张图片

3.3异常处理（捕获异常,处理异常,使程序能够正常执行下去）⭐️

目的

JavaSE-part1_第78张图片

JavaSE-part1_第79张图片

3.3.1try - catch-finally

JavaSE-part1_第80张图片

JavaSE-part1_第81张图片

JavaSE-part1_第82张图片

JavaSE-part1_第83张图片

捕获异常的相关信息⭐️

JavaSE-part1_第84张图片

JavaSE-part1_第85张图片

JavaSE-part1_第86张图片

JavaSE-part1_第87张图片

不捕获异常时的情况⭐️

JavaSE-part1_第88张图片

3.3.2throws

JavaSE-part1_第89张图片

JavaSE-part1_第90张图片

JavaSE-part1_第91张图片

JavaSE-part1_第92张图片

JavaSE-part1_第93张图片

3.3.3手动抛出异常

JavaSE-part1_第94张图片

image-20221221175152894

3.3.4用户自定义异常类

JavaSE-part1_第95张图片

public class MyExpTest {
    public void regist(int num) throws MyException {
        if (num < 0)
            throw new MyException("人数为负值，不合理", 3);
        else
            System.out.println("登记人数" + num);
    }
    public void manager() {
        try {
            regist(100);
        } catch (MyException e) {
            System.out.print("登记失败，出错种类" + e.getId());
        }
        System.out.print("本次登记操作结束");
    }
    public static void main(String args[]) {
        MyExpTest t = new MyExpTest();
        t.manager();
    }
}

class MyException extends Exception {
    static final long serialVersionUID = 13465653435L;//重要
    private int idnumber;
    public MyException(String message, int id) {
        super(message);//将异常信息传给父类，调用父类构造器
        this.idnumber = id;
    }
    public int getId() {
        return idnumber;
    }
}

public class ReturnExceptionDemo {
    static void methodA() {
        try {
            System.out.println("进入方法A");
            throw new RuntimeException("制造异常");
        }finally {
            System.out.println("用A方法的finally");
        }
    }
    static void methodB() {
        try {
            System.out.println("进入方法B");
            return;//return之前也要调用finally方法，finally一定会执行
        } finally {
            System.out.println("调用B方法的finally");
        }
    }
    public static void main(String[] args) {
        try {
            methodA();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        methodB();
    }

//    进入方法A
//    用A方法的finally
//    制造异常
//    进入方法B
//    调用B方法的finally
}

Day04 常用类

1.常用类⭐️⭐️⭐️

1.1包装类

JavaSE-part1_第96张图片

JavaSE-part1_第97张图片

JavaSE-part1_第98张图片

JavaSE-part1_第99张图片

JavaSE-part1_第100张图片

public class Test1 {
    public static void main(String[] args) {
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);//false
        System.out.println(i1.equals(i2));//true 比较的是内容
        System.out.println("-----------");

        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);//false
        System.out.println(i3.equals(i4));//true
        System.out.println("-----------");

        Integer i5 = 128;
        Integer i6 = 128;
        System.out.println(i5 == i6);//false
        System.out.println(i5.equals(i6));//true
        System.out.println("-----------");

        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8);//true
        System.out.println(i7.equals(i8));//true
//        由于我们要经常使用Integer类，所以他会提前为int型创建-128~127一共256个对象，
//        如果在自动装箱的时候给局部变量的int型值是在上面的范围之中，
//        就会直接将之前创建好的对象的地址值赋给等号左边的局部变量
        //new 对象的时候不存在这一说法
//        在第一条中提到过，如果在自动装箱的时候给局部变量的int型值是在上面的范围之中，
//        就会直接将之前创建好的对象的地址值赋给等号左边的局部变量，
//        但是上述代码中在自动装箱时的int型值不在上述范围内，所以会重新new对象，既然会new，那么就不再指向同一个对象了，
//        所以System.out.println(i5 == i6);执行结果为false；
    }
}

1.2String

JavaSE-part1_第101张图片

1.2.1构造器

  • String对象创建的两种方式⭐️⭐️⭐️

image-20221226150450174

JavaSE-part1_第102张图片

JavaSE-part1_第103张图片

JavaSE-part1_第104张图片

image-20221226151101020

		char[] a = {'a','b','c','d'};
        String s = new String(a,0,2);//传入的必须是一个char型数组，不能直接传字符串
        System.out.println(s);//ab

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qmK8T8Zx-1681915855129)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059947.png)]

JavaSE-part1_第105张图片

1.2.2存储位置（区分字符串常量和string对象）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YbB9XVZO-1681915855130)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059949.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bg2lj1RA-1681915855130)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059950.png)]

JavaSE-part1_第106张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6w5K8qXA-1681915855131)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059952.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bqQ2KvLV-1681915855132)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059953.png)]

JavaSE-part1_第107张图片

public class Test2 {
    String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };
    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'b';//传引用数值类型
    }
    public static void main(String[] args) {
            Test2 ex = new Test2();
            ex.change(ex.str, ex.ch);
            System.out.print(ex.str + " and ");//good and best//分清楚局部变量和全局变量
            System.out.println(ex.ch);
    }
}

JavaSE-part1_第108张图片

1.2.3常用方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EaAv8Ktl-1681915855133)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059956.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fuircoto-1681915855133)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059957.png)]

JavaSE-part1_第109张图片

public class MethodTest {
    @Test
    public void test1(){
        //char charAt()
        String a = "abcd";
        System.out.println(a.charAt(0));//a
        //isEmpty();
        System.out.println(a.isEmpty());//false
        //String toUpperCase();
        String a1 = a.toUpperCase(Locale.ROOT);
        System.out.println(a1);//ABCD

        //String trim()
        String a2 = "    abcd   ";
        String trim = a2.trim();
        System.out.println(trim);//abcd
        //boolean equalsIgnoreCase()
        System.out.println(a1.equalsIgnoreCase(trim));//true

        //String concat;
        String a3 = a2.concat(trim);
        System.out.println(a3);//    abcd   abcd

        //compareTo
        String in1 = "456";
        String in2 = "356";
        System.out.println(in1.compareTo(in2));//1表示，大于，4字符的字符值大于3

        //String subString():返回子串
        String substring = in1.substring(1);
        System.out.println(substring);//56
        String substring1 = in1.substring(1, 2);
        System.out.println(substring1);//5
    }
    @Test
    public void test2(){
        //boolean endsWith()
        String s1 = "我爱你中国爱你";
        boolean is = s1.endsWith("中国");
        System.out.println(is);//true
        //boolean startsWith()
        System.out.println(s1.startsWith("你", 2));//true
        System.out.println(s1.startsWith("你", 1));//false
        System.out.println("-----------------------");
        //boolean contains()
        System.out.println(s1.contains("中国"));//true
        System.out.println("-----------------------");

        //int indexOf()：索引
        int ind1 = s1.indexOf("爱你");
        System.out.println(ind1);//1
        int ind2 = s1.indexOf("爱你", 2);
        System.out.println(ind2);//5
        int end1 = s1.lastIndexOf("爱你");
        System.out.println(end1);//5
        int end2 = s1.lastIndexOf("爱你",4);
        System.out.println(end2);//1
    }
    @Test
    public void test3(){
        //String replace()
        String s1 = "哈哈哈哈哈哈哈哈你太可爱啦";
        String s2 = s1.replace('哈', '呜');
        System.out.println(s2);//呜呜呜呜呜呜呜呜你太可爱啦
        String s3 = s1.replace("你太可爱", "你太漂亮");
        System.out.println(s3);//哈哈哈哈哈哈哈哈你太漂亮啦
    }
    @Test
    public void test4() throws UnsupportedEncodingException {
        String str = "中";
        System.out.println(str.getBytes("ISO8859-1").length);// -128~127 //1
        System.out.println(str.getBytes("GBK").length);//2
        System.out.println(str.getBytes("UTF-8").length);//3
        System.out.println(new String(str.getBytes("ISO8859-1"),//乱码
                "ISO8859-1"));// 乱码，表示不了中文
        System.out.println(new String(str.getBytes("GBK"), "GBK"));//中
        System.out.println(new String(str.getBytes("UTF-8"), "UTF-8"));//中，编码和解码结合在一块
//        new String(str.getBytes("UTF-8"),"UTF-8");

    }
}

1.2.4相关转换

JavaSE-part1_第110张图片

JavaSE-part1_第111张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GwhHtxWp-1681915855135)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059961.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F6vXIxr1-1681915855136)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059962.png)]

		//对字符串中的字符进行排序
        //将字符串变为数组，然后调用Arrays.sort()进行排序
        String a = "654897894545613";
        char[] chars = a.toCharArray();
        Arrays.sort(chars);
        System.out.println(chars);//134445556678899
        a = new String(chars);
        System.out.println(a);//134445556678899

1.3StringBuffer类（可变字符串）

1.3.1构造器（缓存区）

JavaSE-part1_第112张图片[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yGZgHNsQ-1681915855137)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059964.png)]

JavaSE-part1_第113张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mwjfMD9p-1681915855138)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059966.png)]

1.3.2常用方法

  • 增删改查插

JavaSE-part1_第114张图片

JavaSE-part1_第115张图片

@Test
    public void test1(){
        StringBuffer buffer = new StringBuffer("abc");
        //append();增
        buffer.append("123");//可用buffer类接收
        System.out.println(buffer);//abc123
        //delete();删
        buffer.delete(3,6);//[3,6)
        System.out.println(buffer);
        //replace();替换
        buffer.replace(0,3,"def");
        System.out.println(buffer);//def
        //insert();插入
        buffer.insert(3,"abc");
        System.out.println(buffer);//defabc
        //reverse();翻转
        buffer.reverse();
        System.out.println(buffer);//cbafed
    }

    @Test
    public void test2(){
        StringBuffer buffer = new StringBuffer("abc");
        //indexOf()
        int index = buffer.indexOf("bc");
        System.out.println(index);//1
        //subString():返回的是String类型的数据
        String substring = buffer.substring(1, 3);
        System.out.println(substring);//bc
        //charAt()
        //setCharAt()
        buffer.setCharAt(1,'a');
        System.out.println(buffer);//aac
    }

1.4StringBuilder类

1.4.1区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wPb48TVy-1681915855139)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059969.png)]

JavaSE-part1_第116张图片

public class Test2 {
    public static void main(String[] args) {
        //初始设置
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
//开始对比
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 200000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 200000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 200000; i++) {
            text = text + i;//每次都是创建一个对象
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));

    }
}
StringBuffer的执行时间：6
StringBuilder的执行时间：0
String的执行时间：3817
  • 经典例子
public class Test3 {
    public static void main(String[] args) {
        String str = null;
        StringBuffer sb = new StringBuffer();
        sb.append(str);
        System.out.println(str);//null
        System.out.println(sb.length());//4
        System.out.println(sb);//null
        StringBuffer sb1 = new StringBuffer(str);
        System.out.println(sb1);//报错
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CExwjgG6-1681915855140)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059971.png)]

JavaSE-part1_第117张图片

JavaSE-part1_第118张图片

1.5Date

1.5.1java8之前

JavaSE-part1_第119张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aIerx1av-1681915855142)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059975.png)]

JavaSE-part1_第120张图片

		Date date = new Date();
        System.out.println(date);//Mon Dec 26 19:33:24 CST 2022
        System.out.println(System.currentTimeMillis());//1672054404487
        System.out.println(date.getTime());//1672054404467
        Date date1 = new Date(date.getTime());
        System.out.println(date1.getTime());//1672054404467
        System.out.println(date1.toString());//Mon Dec 26 19:33:24 CST 2022

image-20221226193602995

public class Format {
    public static void main(String[] args) {
        Date date = new Date(); // 产生一个Date实例
        // 产生一个formater格式化的实例
        SimpleDateFormat formater = new SimpleDateFormat();
        System.out.println(formater.format(date));// 打印输出默认的格式2022/12/26 下午7:41
        SimpleDateFormat formater2 = new SimpleDateFormat("YYYY:MM:dd:HH:mm:ss");
        System.out.println(formater2.format(date));//2022:12:26:19:41:05放入Date类型后，解析成想要输出的格式
        try {
            // 实例化一个指定的格式对象
            Date date2 = formater2.parse("2022:12:26:10:50:20");
            // 将指定的日期解析后格式化按指定的格式输出
            System.out.println(date2.toString());//Sun Dec 26 10:50:20 CST 2021
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-29PpIics-1681915855144)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059978.png)]

public class CalendarTest {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
// 从一个 Calendar 对象中获取 Date 对象
        Date date = calendar.getTime();
// 使用给定的 Date 设置此 Calendar 的时间
        date = new Date(234234235235L);
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, 8);
        System.out.println("当前时间日设置为8后,时间是:" + calendar.getTime());//当前时间日设置为8后,时间是:Wed Jun 08 09:03:55 CST 1977
        calendar.add(Calendar.HOUR, 2);
        System.out.println("当前时间加2小时后,时间是:" + calendar.getTime());//当前时间加2小时后,时间是:Wed Jun 08 11:03:55 CST 1977
        calendar.add(Calendar.MONTH, -2);
        System.out.println("当前日期减2个月后,时间是:" + calendar.getTime());//当前日期减2个月后,时间是:Fri Apr 08 11:03:55 CST 1977
    }
}
1.5.2java8⭐️

JavaSE-part1_第121张图片

JavaSE-part1_第122张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lpCtQuGm-1681915855146)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059981.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lg7PYm5S-1681915855146)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059982.png)]

JavaSE-part1_第123张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k7iGi0ch-1681915855147)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059984.png)]

JavaSE-part1_第124张图片

JavaSE-part1_第125张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bgf4WMup-1681915855149)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059987.png)]

JavaSE-part1_第126张图片

image-20221226195924412

1.6Java比较器⭐️⭐️⭐️

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L30igIsv-1681915855150)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059990.png)]

JavaSE-part1_第127张图片

JavaSE-part1_第128张图片

public class Goods implements Comparable{
    private String name;
    private double price;

    public Goods() {
    }

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods){
            Goods other = (Goods) o;
            if(this.price > other.price){
                return 1;
            }else if(this.price < other.price){
                return -1;
            }
            return 0;
        }
        throw  new RuntimeException("输入类型不匹配");
    }
}

public class ComparableTest {
    public static void main(String[] args) {
        Goods[] all = new Goods[4];
        all[0] = new Goods("《红楼梦》", 100);
        all[1] = new Goods("《西游记》", 80);
        all[2] = new Goods("《三国演义》", 140);
        all[3] = new Goods("《水浒传》", 120);
        Arrays.sort(all);
        System.out.println(Arrays.toString(all));//[Goods{name='《西游记》', price=80.0}, Goods{name='《红楼梦》', price=100.0},
        // Goods{name='《水浒传》', price=120.0}, Goods{name='《三国演义》', price=140.0}]
    }
}
  • 定制排序的作用：①对不方便修改源代码的类，而且需要比较的类②灵活性强，针对comparable

JavaSE-part1_第129张图片

public class ComparatorTest {
    public static void main(String[] args) {
        Goods[] all = new Goods[4];
        all[0] = new Goods("War and Peace", 100);
        all[1] = new Goods("Childhood", 80);
        all[2] = new Goods("Scarlet and Black", 140);
        all[3] = new Goods("Notre Dame de Paris", 120);
        Arrays.sort(all, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Goods g1 = (Goods) o1;
                Goods g2 = (Goods) o2;
                //按名字来排序
                return g1.getName().compareTo(g2.getName());
            }
        });
        System.out.println(Arrays.toString(all));
    }
}

image-20221227115014755

JavaSE-part1_第130张图片

1.7System类

JavaSE-part1_第131张图片

JavaSE-part1_第132张图片

public class Test {
    public static void main(String[] args) {
        String javaVersion = System.getProperty("java.version");
        System.out.println("java的version:" + javaVersion);
        String javaHome = System.getProperty("java.home");
        System.out.println("java的home:" + javaHome);
        String osName = System.getProperty("os.name");
        System.out.println("os的name:" + osName);
        String osVersion = System.getProperty("os.version");
        System.out.println("os的version:" + osVersion);
        String userName = System.getProperty("user.name");
        System.out.println("user的name:" + userName);
        String userHome = System.getProperty("user.home");
        System.out.println("user的home:" + userHome);
        String userDir = System.getProperty("user.dir");
        System.out.println("user的dir:" + userDir);

//        java的version:11.0.16
//        java的home:D:\Environment\Java\jdk11
//        os的name:Windows 10
//        os的version:10.0
//        user的name:666
//        user的home:C:\Users\666
//        user的dir:D:\desktop\666\study\Java\javaseReverse
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FyjL8HJw-1681915855154)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059998.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EAwOu195-1681915855155)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059999.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cVVgShPf-1681915855155)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059000.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ggqd8lwE-1681915855156)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059001.png)]

Day05 集合

1.集合⭐️⭐️⭐️

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3K7M2Yxc-1681915855156)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059002.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IISRF7RR-1681915855157)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059003.png)]

1.1两大分类(collection和map)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pkprnucg-1681915855157)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059004.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-os2jPi13-1681915855158)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059006.png)]

JavaSE-part1_第133张图片

1.2Colltection

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fcBwydMo-1681915855159)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059008.png)]

1.2.1方法

JavaSE-part1_第134张图片

public class Test1 {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());
        System.out.println(coll.size());//4
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);
        System.out.println(coll.size());//6
        System.out.println(coll);//[AA, BB, 123, Tue Dec 27 20:52:51 CST 2022, 456, CC]
        coll.clear();
        System.out.println(coll.isEmpty());//true
    }
}

1.3iterator迭代器

JavaSE-part1_第135张图片

JavaSE-part1_第136张图片

JavaSE-part1_第137张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UNYBUbMS-1681915855161)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059013.png)]

//移除字符串中的2元素
public class Test1 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            arrayList.add(new String(String.valueOf(i)));
        }
        Iterator<String> iterator = arrayList.iterator();
        while(iterator.hasNext()){
            if(iterator.next().equals("2")){
                iterator.remove();
            }
        }
        for(String s : arrayList){
            System.out.print(s + " ");//0 1 3 4 
        }
    }
}

public class MethodTest {
    @Test
    public void test1() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry", 20));
        boolean contains = coll.contains(123);
        System.out.println(contains);//true
        System.out.println(coll.contains(new String("Tom")));//true
        System.out.println(coll.contains(new Person("Jerry", 20)));//false
        //contains内部还是比较equals方法，String重写了equals方法，所以比较的是内容，而Person比较的是地址
        Collection coll1 = Arrays.asList(123, 456);
        System.out.println(coll.containsAll(coll1));//true
    }

    @Test
    public void test2() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);
        System.out.println(coll);//[123, 456, day05.Colltection.Person@3891771e, Tom, false]
        coll.remove(new Person("Jerry", 20));
        Collection coll1 = Arrays.asList(123, 456);
        coll.removeAll(coll1);
        //remove移除元素判断的还是底层的equals方法
        System.out.println(coll);//[day05.Colltection.Person@3891771e, Tom, false]
    }

    @Test
    public void test3() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);
        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(new Person("Jerry", 20));
        coll1.add(new String("Tom"));
        coll1.add(false);
        //coll.equals方法经过重写，还是调用每一个对象的equals方法比较
        System.out.println(coll.equals(coll1));//false
    }

    @Test
    public void test4() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);
        System.out.println(coll.hashCode());
        Object[] arr = coll.toArray();

        for(int i = 0; i < arr.length; ++i) {
            System.out.println(arr[i]);
        }

        List<String> list = Arrays.asList("AA", "BB", "CC");
        System.out.println(list);
        Iterator var4 = list.iterator();

        while(var4.hasNext()) {
            String l = (String)var4.next();
            System.out.println(l);
        }

        List arr1 = Arrays.asList(new int[]{123, 456});
        System.out.println(arr1.size());//1,就一个数组元素
        System.out.println(arr1);
        List arr2 = Arrays.asList(123, 456);
        //接收参数是一个可变形参数组
        //return new ArrayList<>(a);两个元素
        System.out.println(arr2.size());//2
    }
}
class Person{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

@Test
    public void test2() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);
		//这里会出错，因为每次调用iterator都会生成一个新的迭代器，所以会无限循环
        while(coll.iterator().hasNext()) {
            System.out.println(coll.iterator().next());
        }

    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y2Uv9sJX-1681915855161)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059014.png)]

1.4List接口

JavaSE-part1_第138张图片

1.4.1方法

  • 增加了一些有关索引的方法

增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：① Iterator迭代器方式
② 增强for循环
③ 普通的循环

JavaSE-part1_第139张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rFEa1LOC-1681915855163)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059017.png)]

public class Test {
    @org.junit.Test
    public void test3() {
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        Iterator iterator = list.iterator();

        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
//        123
//        456
//        AA

        System.out.println("**************");
        Iterator var3 = list.iterator();

        while(var3.hasNext()) {
            Object obj = var3.next();
            System.out.println(obj);
        }
        //        123
         //        456
         //        AA

        System.out.println("**************");

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

    }

    @org.junit.Test
    public void test2() {
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom", 12));
        list.add(456);
        int index = list.indexOf(456);
        System.out.println(index);//1
        System.out.println(list.lastIndexOf(456));//4
        Object obj = list.remove(0);
        System.out.println(obj);//123
        System.out.println(list);//[456, AA, day05.ListTest.Person@3891771e, 456]
        list.set(1, "CC");
        System.out.println(list);//[456, CC, day05.ListTest.Person@3891771e, 456]
        List subList = list.subList(2, 4);
        System.out.println(subList);//[day05.ListTest.Person@3891771e, 456]
    }

    @org.junit.Test
    public void test1() {
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom", 12));
        list.add(456);
        //可重复
        System.out.println(list);//[123, 456, AA, day05.ListTest.Person@3891771e, 456]
        //添加到1处，"BB"
        list.add(1, "BB");
        System.out.println(list);//[123, BB, 456, AA, day05.ListTest.Person@3891771e, 456]
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list.size());//9
        System.out.println(list);//[123, BB, 456, AA, day05.ListTest.Person@3891771e, 456, 1, 2, 3]
        System.out.println(list.get(0));//123
    }
}
class Person{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

实现类

1.4.2ArrayList

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hpy8mDJf-1681915855163)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059018.png)]

JavaSE-part1_第140张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hj34hIMp-1681915855164)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059020.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4QsGetJw-1681915855165)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059021.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3EmaX4qN-1681915855165)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059022.jpg)]

public class ArrayListTest {
    public static void testListRemove() {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);
        System.out.println(list);//[1, 2]
    }
    private static void updateList(List list) {
        list.remove(2);
    }

    public static void main(String[] args) {
        testListRemove();
    }
}

1.4.3LinkedList

  • 不推荐加入null元素

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a9VrMTLD-1681915855166)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059023.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VE0sLaYK-1681915855167)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059024.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O4yNnaz9-1681915855168)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059025.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AkDJefuN-1681915855168)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059026.png)]

1.4.4Vector

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O8dEPDq6-1681915855169)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059027.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9YthTbqq-1681915855170)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059028.png)]

1.5Set接口(无索引)

  1. 存储的数据特点：无序的、不可重复的元素
    具体的：
    以HashSet为例说明：

无序性：不等于随机性。存储的数据在底层数组中并非照数组索引的顺序添加，而是根据数据的哈希值决定的。

不可重复性：保证添加的元素照equals()判断时，不能返回true.即：相同的元素只能添加一个。

所以要添加自定义的对象时，一定要重写hashcode()和equals()方法，添加自定义对象时先判断hashcode如果不一样，那么不判断equals()方法，认为不一样。这样可以提高判断效率。因此要重写hashcode和equals方法

可以理解为hashcode是第一关，第一关通过第二关equals方法再通过，就完全相同。

Object中的hashcode()方法没有属性依据随机随机算得一个数，所以调用的话hashcode值不会一样

总之一定要保证相等的对象有相同的hashcode

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tuW3U3bj-1681915855171)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059029.png)]

2.元素添加过程：(以HashSet为例)

散列函数计算还尽可能保证能均匀存储元素

3.底层结构:散列数组 + 链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hLHF1Snw-1681915855172)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059030.png)]

4.Set接口中的方法都是Colltecion中的方法，没有修改的方法

5.因为Set接口的值不可重复，Map接口中key不可重复，所以都有Tree结构进行排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rse5OJis-1681915855172)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059031.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hqCOBtiG-1681915855173)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059032.png)]

1.5.1==HashSet==

  • 集合中的元素可以为null

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pa8hPcDX-1681915855174)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059033.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MTMAkMS3-1681915855175)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059034.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9pWpV2z8-1681915855176)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059035.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5dTCP5n9-1681915855177)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059036.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6O0lYPS5-1681915855177)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059037.png)]

1.5.2==LinkedHashSet==（适合遍历，遍历效率高）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vj3IEACY-1681915855178)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059038.png)]

JavaSE-part1_第141张图片

1.5.3==TreeSet(同一对象，定制排序)==

  • 这个里面不再按hashcode和equals方法去比，而是按照重写的comparable接口去比，底层是树形结构，不是数组，不允许有相同的数据出现

    JavaSE-part1_第142张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gZ18XjZ0-1681915855179)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059041.png)]

JavaSE-part1_第143张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TvCMAYXu-1681915855180)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059043.png)]

JavaSE-part1_第144张图片

JavaSE-part1_第145张图片

1.6Map接口

1.6.1概述

1.一般使用HashMap，HashMap的线程不安全性，可由Collections工具类来解决

2.TreeMap排序的时候，考虑key的自然排序和定制排序

3.底层结构⭐️ 数组 + 链表 + 存储元素(entry或node)

4.内部类只能对外部类范围内有效，只能使用外部类中的成员，与别的成员无联系，所以声明为内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qJpWds6w-1681915855182)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059046.png)]

JavaSE-part1_第146张图片

JavaSE-part1_第147张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ykbPaSLC-1681915855184)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059049.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hcVGZDQu-1681915855184)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059050.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-btnAMYSA-1681915855185)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059051.png)]

image-20221229193812454

1.6.2底层实现原理

JavaSE-part1_第148张图片

JavaSE-part1_第149张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iLpvR8Or-1681915855188)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059055.png)]

JavaSE-part1_第150张图片

JavaSE-part1_第151张图片

JavaSE-part1_第152张图片

JavaSE-part1_第153张图片

以上为jdk7

JavaSE-part1_第154张图片

1.6.3常用方法

总结：常用方法：

  • 添加：put(Object key,Object value)
  • 删除：remove(Object key)
  • 修改：put(Object key,Object value)
  • 查询：get(Object key)
  • 长度：size()
  • 遍历：keySet() / values() / entrySet()
  • 没有插入方法，因为没有顺序何谈插入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JTdEIx8t-1681915855191)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059061.png)]

JavaSE-part1_第155张图片

JavaSE-part1_第156张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2LBwXnyF-1681915855193)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059064.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YXHyyuTB-1681915855193)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059065.png)]

/*
     添加、删除、修改操作：
 Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
 void putAll(Map m):将m中的所有key-value对存放到当前map中
 Object remove(Object key)：移除指定key的key-value对，并返回value
 void clear()：清空当前map中的所有数据
     */
    @Test
    public void test3(){
        Map map = new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        //修改
        ///
        map.put("AA",87);//重复添加相同的key，会修改value

        System.out.println(map);//{AA=87, BB=56, 45=123}

        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);

        map.putAll(map1);

        System.out.println(map);

        //remove(Object key)
        Object value = map.remove("CC");
        System.out.println(value);//123，返回要移除的键值对的value
        System.out.println(map);//{AA=87, BB=56, DD=123, 45=123}

        //clear()
        map.clear();//与map = null操作不同
        System.out.println(map.size());//0，map还在，只是将里面存的数据清除
        System.out.println(map);//{}
    }

    /*
 元素查询的操作：
 Object get(Object key)：获取指定key对应的value
 boolean containsKey(Object key)：是否包含指定的key
 boolean containsValue(Object value)：是否包含指定的value
 int size()：返回map中key-value对的个数
 boolean isEmpty()：判断当前map是否为空
 boolean equals(Object obj)：判断当前map和参数对象obj是否相等
     */
    @Test
    public void test4(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        // Object get(Object key)
        System.out.println(map.get(45));//123
        //containsKey(Object key)
        boolean isExist = map.containsKey("BB");
        System.out.println(isExist);

        isExist = map.containsValue(123);
        System.out.println(isExist);

        map.clear();

        System.out.println(map.isEmpty());//true

    }
  • 遍历方法(Map没有实现iterator接口，因此不能用迭代器遍历)
  • 遍历方法：拿到key和value，key是由Set存储，value是由Colltection存储，因此用元视图方法得到然后遍历
  • 目的：从键值对中依次地取数据
@Test
    public void test5(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);

        //遍历所有的key集：keySet()
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //AA BB 45
        System.out.println();
        //遍历所有的value集：values()
        Collection values = map.values();
        for(Object obj : values){
            System.out.println(obj);
        }
        System.out.println();
        //遍历所有的key-value
        //方式一：entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
        System.out.println();
        //方式二：
        Set keySet = map.keySet();
        Iterator iterator2 = keySet.iterator();
        while(iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = map.get(key);
            System.out.println(key + "=====" + value);

        }

    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DuL6pOvM-1681915855194)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059066.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JKvKR9Dt-1681915855194)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059067.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NcBf4LfM-1681915855195)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059068.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zOcz0Jn5-1681915855196)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059069.png)]

1.6.4HashMap

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xjn9vzpR-1681915855196)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059070.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0aQsB3VM-1681915855197)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059071.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wTqPFgNW-1681915855197)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059072.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NseCTWNS-1681915855198)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059073.png)]

1.6.5对理解key以Set存储很重要

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WStRcZDl-1681915855198)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059074.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-71sftptU-1681915855199)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059075.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vDgdd0pq-1681915855199)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059076.png)]

1.6.6重点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ImUYHQLZ-1681915855200)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059077.png)]

1.6.7LinkHashMap

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TbplKZ4R-1681915855200)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059078.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VaAwkfRz-1681915855200)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059079.png)]

1.6.8TreeMap

  • 注意点只能按照key排序，不能按照value排序，因为value是可重复的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MKa1CcIw-1681915855200)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059080.png)]

public class User implements Comparable{
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("User equals()....");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() { //return name.hashCode() + age;
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    //按照姓名从大到小排列,年龄从小到大排列
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
//            return -this.name.compareTo(user.name);
            int compare = -this.name.compareTo(user.name);
            if(compare != 0){
                return compare;
            }else{
                return Integer.compare(this.age,user.age);
            }
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }

    }
}

    //向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
    //因为要按照key进行排序：自然排序 、定制排序
    //自然排序
    @Test
    public void test1(){
        TreeMap map = new TreeMap();
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);
        map.put(u2,89);
        map.put(u3,76);
        map.put(u4,100);

        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
//        User{name='Tom', age=23}---->98
//        User{name='Rose', age=18}---->100
//        User{name='Jerry', age=32}---->89
//        User{name='Jack', age=20}---->76
    }

//定制排序
    @Test
    public void test2(){
        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }
                throw new RuntimeException("输入的类型不匹配！");
            }
        });
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);
        map.put(u2,89);
        map.put(u3,76);
        map.put(u4,100);

        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
    }

1.6.9Properties

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8E8qBcQC-1681915855201)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059081.png)]

public class Properties {
    //Properties:常用来处理配置文件。key和value都是String类型
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            java.util.Properties pros = new java.util.Properties();

            fis = new FileInputStream("jdbc.properties");
            pros.load(fis);//加载流对应的文件

            String name = pros.getProperty("name");
            String password = pros.getProperty("password");

            System.out.println("name = " + name + ", password = " + password);
            //name = Tom宋红康, password = abc123
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}

1.7Collections工具类（如数组有Arrays工具类）

  • 操作Collection和Map的工具类

  • 排序方法都是针对List接口的 Arrays工具类针对数组排序

  • size()方法表示存了几个元素

  • 将集合转变为同步的方法synchronizedList()

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JlDcWplJ-1681915855202)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059082.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rsLQrNfC-1681915855202)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059083.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LviVSNTz-1681915855203)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059084.png)]

        /*
    reverse(List)：反转 List 中元素的顺序
    shuffle(List)：对 List 集合元素进行随机排序
    sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
    sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
    swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

    Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
    Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
    Object min(Collection)
    Object min(Collection，Comparator)
    int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
    void copy(List dest,List src)：将src中的内容复制到dest中
    boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

     */
    @Test
    public void test2(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(-97);
        list.add(0);

        //报异常：IndexOutOfBoundsException("Source does not fit in dest")
//        List dest = new ArrayList();//这里如果指定长度，那么指定的是底层数组造了几个，而不是实际存的元素
//        Collections.copy(dest,list);
        //正确的：
        List dest = Arrays.asList(new Object[list.size()]);
        System.out.println(dest.size());//list.size(); //5
        Collections.copy(dest,list);

        System.out.println(dest);//[123, 43, 765, -97, 0]


        /*
        Collections 类中提供了多个 synchronizedXxx() 方法，
        该方法可使将指定集合包装成线程同步的集合，从而可以解决
        多线程并发访问集合时的线程安全问题

         */
        //返回的list1即为线程安全的List
        List list1 = Collections.synchronizedList(list);


    }

    @Test
    public void test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(765);
        list.add(765);
        list.add(-97);
        list.add(0);

        System.out.println(list);//[123, 43, 765, 765, 765, -97, 0]

//        Collections.reverse(list);
//        Collections.shuffle(list);
//        Collections.sort(list);
//        Collections.swap(list,1,2);
        int frequency = Collections.frequency(list, 123);

        System.out.println(list);//[123, 43, 765, 765, 765, -97, 0]
        System.out.println(frequency);//1

    }

总结

JavaSE-part1_第157张图片

Day06 泛型

1.泛型(只在编译期有效，运行时被擦除)

1.1基础概念

  • 泛型可通俗理解为占位符
  • 泛型解决了强制类型转换的问题
  • Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生 ClassCastException异常。同时，代码更加简洁、健壮。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X7JR8lK8-1681915855203)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059086.png)]

JavaSE-part1_第158张图片

JavaSE-part1_第159张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rxcxJqFq-1681915855205)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059089.png)]

image-20221231165602244

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2PdWwTBu-1681915855206)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059092.png)]

1.2基本使用

ArrayList<Integer> list = new ArrayList<>();//类型推断
list.add(78);
list.add(88);
list.add(77);
list.add(66);
//遍历方式一：
//for(Integer i : list){
//不需要强转
//System.out.println(i);
//}
//遍历方式二：
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}


Map<String,Integer> map = new HashMap<String,Integer>();
map.put("Tom1",34);
map.put("Tom2",44);
map.put("Tom3",33);
map.put("Tom4",32);
//添加失败
//map.put(33, "Tom");
Set<Entry<String,Integer>> entrySet = map.entrySet();
Iterator<Entry<String,Integer>> iterator = entrySet.iterator();
while(iterator.hasNext()){
Entry<String,Integer> entry = iterator.next();
System.out.println(entry.getKey() + "--->" + entry.getValue());
}

1.3自定义泛型类⭐️⭐️⭐️

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0ok8zBIC-1681915855206)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059093.png)]

JavaSE-part1_第160张图片

JavaSE-part1_第161张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HUqOUDTr-1681915855208)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059096.png)]

1.4特性

  • 泛型只在编译阶段有效。
  • 泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pUkUKceW-1681915855208)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059097.png)]

1.5泛型类

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  .....

  }
}

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型,否则T为Object类型
public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;

    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }

    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}

JavaSE-part1_第162张图片

JavaSE-part1_第163张图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gfWFlwib-1681915855210)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059100.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sAk6wlSj-1681915855210)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059101.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bBMBliBZ-1681915855211)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059102.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l2WgOY0W-1681915855211)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059103.png)]

1.6泛型接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1GjUuKwO-1681915855212)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059104.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E5MMNyRR-1681915855212)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059105.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zltiDc03-1681915855213)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059106.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lgEftlur-1681915855213)(https://weifengqin-image.oss-cn-nanjing.aliyuncs.com/img/202304180059107.png)]

JavaSE-part1_第164张图片

JavaSE-part1_第165张图片

1.7泛型方法

  • 特点：调用的时候自动类型推断，不用<>指明类型

image-20221231205316157

JavaSE-part1_第166张图片

JavaSE-part1_第167张图片

JavaSE-part1_第168张图片

JavaSE-part1_第169张图片

JavaSE-part1_第170张图片

JavaSE-part1_第171张图片

JavaSE-part1_第172张图片
  • 可以说泛型类中的T什么的，都是在编译类的时候确定，而static方法在类加载就要确定T类型，因此不生效
  • 而泛型方法影响的只是参数，static方法在类加载的时候可以不先关注参数，因此成立

1.8泛型的继承和通配符⭐️⭐️⭐️

  • 1.

JavaSE-part1_第173张图片

JavaSE-part1_第174张图片

JavaSE-part1_第175张图片

  • 同一个类型不同泛型之间没关系，但是不同类型，同一种泛型之间有子父类关系

  • JavaSE-part1_第176张图片

    JavaSE-part1_第177张图片

JavaSE-part1_第178张图片

  • 第二种方式

JavaSE-part1_第179张图片

image-20221231215149668

  • 通配符

  • 通配符是泛型<>的通用父类

  • JavaSE-part1_第180张图片

    JavaSE-part1_第181张图片

JavaSE-part1_第182张图片

  • 通配符：写入

  • JavaSE-part1_第183张图片

  • 通配符：读取

  • JavaSE-part1_第184张图片

  • 有限制条件的通配符

  • ?(-…,+…) extends <= super >=

  • JavaSE-part1_第185张图片

/*
    3.有限制条件的通配符的使用。
        ? extends A:
                G 可以作为G和G的父类，其中B是A的子类

        ? super A:
                G 可以作为G和G的父类，其中B是A的父类

     */
    @Test
    public void test4(){

        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;

        List<Student> list3 = new ArrayList<Student>();
        List<Person> list4 = new ArrayList<Person>();
        List<Object> list5 = new ArrayList<Object>();

        list1 = list3;
        list1 = list4;
//        list1 = list5;

//        list2 = list3;
        list2 = list4;
        list2 = list5;

        //读取数据：
        list1 = list3;
        Person p = list1.get(0);//可以用Person，Object，因为小于等于Person
        //编译不通过
        //Student s = list1.get(0);//因为不确定是不是Student/重要///

        list2 = list4;
        Object obj = list2.get(0);//这里只能是Object，因为大于等于Person，Object能确定
        编译不通过
//        Person obj = list2.get(0);

        //写入数据：
        //编译不通过
//        list1.add(new Student());
        
        //编译通过
        list2.add(new Person());//这里就可以往小的写，因为最小是Person，你只要往里传Person子类就可以
        list2.add(new Student());

    }

JavaSE-part1_第186张图片
图片转存中…(img-3iLUjsKg-1681915855214)]

[外链图片转存中…(img-W1ZQ5wOT-1681915855214)]

1.7泛型方法

  • 特点：调用的时候自动类型推断，不用<>指明类型

[外链图片转存中…(img-2Z4u4gBE-1681915855215)]

[外链图片转存中…(img-0xd0Fz00-1681915855216)]

[外链图片转存中…(img-0EnPPJqC-1681915855216)]

[外链图片转存中…(img-hhsRUXYs-1681915855216)]

[外链图片转存中…(img-MkcMESUz-1681915855217)]

[外链图片转存中…(img-mH32zGXw-1681915855217)]

[外链图片转存中…(img-nmBwaz0n-1681915855218)]

JavaSE-part1_第187张图片
  • 可以说泛型类中的T什么的，都是在编译类的时候确定，而static方法在类加载就要确定T类型，因此不生效
  • 而泛型方法影响的只是参数，static方法在类加载的时候可以不先关注参数，因此成立

1.8泛型的继承和通配符⭐️⭐️⭐️

  • 1.

[外链图片转存中…(img-mRiEz0tI-1681915855218)]

[外链图片转存中…(img-0IoNK78Z-1681915855218)]

[外链图片转存中…(img-0zT9udOA-1681915855219)]

  • 同一个类型不同泛型之间没关系，但是不同类型，同一种泛型之间有子父类关系

  • [外链图片转存中…(img-fP8fz3gU-1681915855220)]

    [外链图片转存中…(img-E49HOR7b-1681915855220)]

[外链图片转存中…(img-b097q7su-1681915855221)]

  • 第二种方式

[外链图片转存中…(img-ENU0qh1h-1681915855221)]

[外链图片转存中…(img-ZgCugI5A-1681915855222)]

  • 通配符

  • 通配符是泛型<>的通用父类

  • [外链图片转存中…(img-C4TDkXXp-1681915855222)]

    [外链图片转存中…(img-Uzmz0AYz-1681915855223)]

[外链图片转存中…(img-S6oFZWYg-1681915855223)]

  • 通配符：写入

  • [外链图片转存中…(img-30GNC9NC-1681915855224)]

  • 通配符：读取

  • [外链图片转存中…(img-2qx26DO7-1681915855224)]

  • 有限制条件的通配符

  • ?(-…,+…) extends <= super >=

  • [外链图片转存中…(img-fROlq9MX-1681915855225)]

/*
    3.有限制条件的通配符的使用。
        ? extends A:
                G 可以作为G和G的父类，其中B是A的子类

        ? super A:
                G 可以作为G和G的父类，其中B是A的父类

     */
    @Test
    public void test4(){

        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;

        List<Student> list3 = new ArrayList<Student>();
        List<Person> list4 = new ArrayList<Person>();
        List<Object> list5 = new ArrayList<Object>();

        list1 = list3;
        list1 = list4;
//        list1 = list5;

//        list2 = list3;
        list2 = list4;
        list2 = list5;

        //读取数据：
        list1 = list3;
        Person p = list1.get(0);//可以用Person，Object，因为小于等于Person
        //编译不通过
        //Student s = list1.get(0);//因为不确定是不是Student/重要///

        list2 = list4;
        Object obj = list2.get(0);//这里只能是Object，因为大于等于Person，Object能确定
        编译不通过
//        Person obj = list2.get(0);

        //写入数据：
        //编译不通过
//        list1.add(new Student());
        
        //编译通过
        list2.add(new Person());//这里就可以往小的写，因为最小是Person，你只要往里传Person子类就可以
        list2.add(new Student());

    }

[外链图片转存中…(img-szU59kNK-1681915855225)]

你可能感兴趣的:(JavaSE,java,jvm,开发语言)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • 常见的 JVM 调优方法有哪些？ 爪哇天下 jvm
    常见的JVM调优方法有哪些？可以具体到调整哪个参数，调成什么值？对年轻代的EdenSurvivor的比例进行配置-XX:SurvivorRatio=8：表示设置2个Survivor区：1个Eden区的大小比值为2:8，这意味着Survivor区占整个年轻代的1/5，这个参数默认为8如果经常性的SurvivorTo放不下YGC的剩余的对象时候，可以适当的调整比例常用的CMS收集器：设置回收阈值，需要
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
  • 集合框架 天子之骄 java数据结构集合框架
       集合框架 集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。 从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。   简单介绍：   Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
  • Table Driven（表驱动）方法实例 bijian1013 javaenumTable Driven表驱动
    实例一： /** * 驾驶人年龄段 * 保险行业，会对驾驶人的年龄做年龄段的区分判断 * 驾驶人年龄段：01-[18,25);02-[25,30);03-[30-35);04-[35,40);05-[40,45);06-[45,50);07-[50-55);08-[55,+∞) */ public class AgePeriodTest { //if...el
  • Jquery 总结 cuishikuan javajqueryAjaxWebjquery方法
    1.$.trim方法用于移除字符串头部和尾部多余的空格。如：$.trim('   Hello   ') // Hello2.$.contains方法返回一个布尔值，表示某个DOM元素（第二个参数）是否为另一个DOM元素（第一个参数）的下级元素。如：$.contains(document.documentElement, document.body); 3.$
  • 面向对象概念的提出 麦田的设计者 java面向对象面向过程
            面向对象中，一切都是由对象展开的，组织代码，封装数据。   在台湾面向对象被翻译为了面向物件编程，这充分说明了，这种编程强调实体。       下面就结合编程语言的发展史，聊一聊面向过程和面向对象。      c语言由贝尔实
  • linux网口绑定 被触发 linux
    刚在一台IBM Xserver服务器上装了RedHat Linux Enterprise AS 4，为了提高网络的可靠性配置双网卡绑定。 一、环境描述 我的RedHat Linux Enterprise AS 4安装双口的Intel千兆网卡，通过ifconfig -a命令看到eth0和eth1两张网卡。 二、双网卡绑定步骤： 2.1 修改/etc/sysconfig/network
  • XML基础语法 肆无忌惮_ xml
    一、什么是XML？ XML全称是Extensible Markup Language，可扩展标记语言。很类似HTML。XML的目的是传输数据而非显示数据。XML的标签没有被预定义，你需要自行定义标签。XML被设计为具有自我描述性。是W3C的推荐标准。   二、为什么学习XML？ 用来解决程序间数据传输的格式问题 做配置文件 充当小型数据库   三、XML与HTM
  • 为网页添加自己喜欢的字体 知了ing 字体 秒表 css
    @font-face { font-family: miaobiao;//定义字体名字 font-style: normal; font-weight: 400; src: url('font/DS-DIGI-e.eot');//字体文件 } 使用： <label style="font-size:18px;font-famil
  • redis范围查询应用-查找IP所在城市 矮蛋蛋 redis
    原文地址： http://www.tuicool.com/articles/BrURbqV 需求 根据IP找到对应的城市 原来的解决方案 oracle表（ip_country）： 查询IP对应的城市： 1.把a.b.c.d这样格式的IP转为一个数字，例如为把210.21.224.34转为3524648994 2. select city from ip_
  • 输入两个整数， 计算百分比 alleni123 java
    public static String getPercent(int x, int total){ double result=(x*1.0)/(total*1.0); System.out.println(result); DecimalFormat df1=new DecimalFormat("0.0000%");
  • 百合——————>怎么学习计算机语言 百合不是茶 java 移动开发
        对于一个从没有接触过计算机语言的人来说，一上来就学面向对象，就算是心里上面接受的了，灵魂我觉得也应该是跟不上的，学不好是很正常的现象，计算机语言老师讲的再多，你在课堂上面跟着老师听的再多，我觉得你应该还是学不会的，最主要的原因是你根本没有想过该怎么来学习计算机编程语言，记得大一的时候金山网络公司在湖大招聘我们学校一个才来大学几天的被金山网络录取，一个刚到大学的就能够去和
  • linux下tomcat开机自启动 bijian1013 tomcat
    方法一： 修改Tomcat/bin/startup.sh 为: export JAVA_HOME=/home/java1.6.0_27 export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:. export PATH=$JAVA_HOME/bin:$PATH export CATALINA_H
  • spring aop实例 bijian1013 javaspringAOP
    1.AdviceMethods.java package com.bijian.study.spring.aop.schema; public class AdviceMethods { public void preGreeting() { System.out.println("--how are you!--"); } } 2.beans.x
  • [Gson八]GsonBuilder序列化和反序列化选项enableComplexMapKeySerialization bit1129 serialization
    enableComplexMapKeySerialization配置项的含义  Gson在序列化Map时，默认情况下，是调用Key的toString方法得到它的JSON字符串的Key，对于简单类型和字符串类型，这没有问题，但是对于复杂数据对象，如果对象没有覆写toString方法，那么默认的toString方法将得到这个对象的Hash地址。   GsonBuilder用于
  • 【Spark九十一】Spark Streaming整合Kafka一些值得关注的问题 bit1129 Stream
    包括Spark Streaming在内的实时计算数据可靠性指的是三种级别： 1. At most once，数据最多只能接受一次，有可能接收不到 2. At least once, 数据至少接受一次，有可能重复接收 3. Exactly once  数据保证被处理并且只被处理一次，   具体的多读几遍http://spark.apache.org/docs/lates
  • shell脚本批量检测端口是否被占用脚本 ronin47
    #!/bin/bash cat ports |while read line do#nc -z -w 10 $line nc -z -w 2 $line 58422>/dev/null2>&1if[ $?-eq 0]then echo $line:ok else echo $line:fail fi done 这里的ports 既可以是文件
  • java-2.设计包含min函数的栈 bylijinnan java
    具体思路参见：http://zhedahht.blog.163.com/blog/static/25411174200712895228171/ import java.util.ArrayList; import java.util.List; public class MinStack { //maybe we can use origin array rathe
  • Netty源码学习-ChannelHandler bylijinnan javanetty
    一般来说，“有状态”的ChannelHandler不应该是“共享”的，“无状态”的ChannelHandler则可“共享” 例如ObjectEncoder是“共享”的, 但 ObjectDecoder 不是 因为每一次调用decode方法时，可能数据未接收完全（incomplete）， 它与上一次decode时接收到的数据“累计”起来才有可能是完整的数据，是“有状态”的 p
  • java生成随机数 cngolon java
    方法一： /** * 生成随机数 * @author [email protected] * @return */ public synchronized static String getChargeSequenceNum(String pre){ StringBuffer sequenceNum = new StringBuffer(); Date dateTime = new D
  • POI读写海量数据 ctrain 海量数据
    import java.io.FileOutputStream; import java.io.OutputStream; import org.apache.poi.xssf.streaming.SXSSFRow; import org.apache.poi.xssf.streaming.SXSSFSheet; import org.apache.poi.xssf.streaming
  • mysql 日期格式化date_format详细使用 daizj mysqldate_format日期格式转换日期格式化
    日期转换函数的详细使用说明  DATE_FORMAT(date,format) Formats the date value according to the format string. The following specifiers may be used in the format string. The&n
  • 一个程序员分享8年的开发经验 dcj3sjt126com 程序员
      在中国有很多人都认为IT行为是吃青春饭的，如果过了30岁就很难有机会再发展下去!其实现实并不是这样子的，在下从事.NET及JAVA方面的开发的也有8年的时间了，在这里在下想凭借自己的亲身经历，与大家一起探讨一下。 明确入行的目的 很多人干IT这一行都冲着“收入高”这一点的，因为只要学会一点HTML, DIV+CSS，要做一个页面开发人员并不是一件难事，而且做一个页面开发人员更容
  • android欢迎界面淡入淡出效果 dcj3sjt126com android
    很多Android应用一开始都会有一个欢迎界面，淡入淡出效果也是用得非常多的，下面来实现一下。 主要代码如下： package com.myaibang.activity; import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.os.CountDown
  • linux 复习笔记之常见压缩命令 eksliang tar解压linux系统常见压缩命令linux压缩命令tar压缩
    转载请出自出处:http://eksliang.iteye.com/blog/2109693 linux中常见压缩文件的拓展名 *.gz gzip程序压缩的文件 *.bz2 bzip程序压缩的文件 *.tar tar程序打包的数据，没有经过压缩 *.tar.gz tar程序打包后，并经过gzip程序压缩 *.tar.bz2 tar程序打包后，并经过bzip程序压缩 *.zi
  • Android 应用程序发送shell命令 gqdy365 android
    项目中需要直接在APP中通过发送shell指令来控制lcd灯，其实按理说应该是方案公司在调好lcd灯驱动之后直接通过service送接口上来给APP，APP调用就可以控制了，这是正规流程，但我们项目的方案商用的mtk方案，方案公司又没人会改，只调好了驱动，让应用程序自己实现灯的控制，这不蛋疼嘛！！！！ 发就发吧！ 一、关于shell指令： 我们知道，shell指令是Linux里面带的
  • java 无损读取文本文件 hw1287789687 读取文件无损读取读取文本文件charset
    java 如何无损读取文本文件呢？ 以下是有损的 @Deprecated public static String getFullContent(File file, String charset) { BufferedReader reader = null; if (!file.exists()) { System.out.println("getFull
  • Firebase 相关文章索引 justjavac firebase
    Awesome Firebase 最近谷歌收购Firebase的新闻又将Firebase拉入了人们的视野，于是我做了这个 github 项目。 Firebase 是一个数据同步的云服务，不同于 Dropbox 的「文件」，Firebase 同步的是「数据」，服务对象是网站开发者，帮助他们开发具有「实时」（Real-Time）特性的应用。 开发者只需引用一个 API 库文件就可以使用标准 RE
  • C++学习重点 lx.asymmetric C++笔记
    1.c++面向对象的三个特性：封装性，继承性以及多态性。   2.标识符的命名规则：由字母和下划线开头，同时由字母、数字或下划线组成；不能与系统关键字重名。   3.c++语言常量包括整型常量、浮点型常量、布尔常量、字符型常量和字符串性常量。   4.运算符按其功能开以分为六类：算术运算符、位运算符、关系运算符、逻辑运算符、赋值运算符和条件运算符。 &n
  • java bean和xml相互转换 q821424508 javabeanxmlxml和bean转换java bean和xml转换
    这几天在做微信公众号 做的过程中想找个java bean转xml的工具，找了几个用着不知道是配置不好还是怎么回事，都会有一些问题， 然后脑子一热谢了一个javabean和xml的转换的工具里，自己用着还行，虽然有一些约束吧 ， 还是贴出来记录一下      顺便你提一下下，这个转换工具支持属性为集合、数组和非基本属性的对象。   packag
  • C 语言初级 位运算 1140566087 位运算c
    第十章 位运算   1、位运算对象只能是整形或字符型数据，在VC6.0中int型数据占4个字节   2、位运算符： 运算符 作用 ~ 按位求反 << 左移 >> 右移 & 按位与 ^ 按位异或 | 按位或 他们的优先级从高到低；   3、位运算符的运算功能： a、按位取反： ~01001101 = 101
  • 14点睛Spring4.1-脚本编程 wiselyman spring4
    14.1 Scripting脚本编程 脚本语言和java这类静态的语言的主要区别是:脚本语言无需编译,源码直接可运行; 如果我们经常需要修改的某些代码,每一次我们至少要进行编译,打包,重新部署的操作,步骤相当麻烦; 如果我们的应用不允许重启,这在现实的情况中也是很常见的; 在spring中使用脚本编程给上述的应用场景提供了解决方案,即动态加载bean; spring支持脚本
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他