Map集合-Java

Map集合概述

  1. 双列集合每一个元素包括两个值key和value，两者数据类型可以相同，也可以不用
  2. key不可以重复，value可以重复
  3. key和value一一对应

Map常用子类

  • HashMap:无序集合，底层是哈希表。当存储自定义类型键值，需要重写toString和equals方法。
  • LinkedHashMap：HashMap的子类，有序集合，存储和取出顺序相同。

Map常用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("hxx", 22);
        map.put("qzy", 23);
        //使用Map集合中的方法entryset，将Map集合中的Entry对象存储到set集合中
        Set<Map.Entry<String, Integer>> set = map.entrySet();
        //遍历
        for (Map.Entry<String, Integer> entry : set) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "----" + value);
        }
   }

Collections工具类-Java

常用功能

  • public static < T > bollean addAll(Collection< T > c,T…elements)：往集合中添加元素
  • public static void shutffle(List<?>list):打乱顺序
  • public static < T > sort(List<?>list):按默认规则升序排序
  • public static < T > sort(List<?>list，Comparator<? Super T>):按指定规则排序

对已有类型排序

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(1);
        Collections.sort(list);
        Collections.sort(list, new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o1-o2;
                }
            });
}

对自定义类型排序：对Comparable重写定义排序规则：this-参数（升序）

1
2
3
4
5
6
7
8
9
public class Person implements Comparable{
    private String name;
    private int age;
//....
    @Override
    public int compareTo(Object o) {
        return this.getAge() - ((Person)o).getAge();//按照年龄升序
    }
}
1
2
3
4
5
6
7
8
9
10
Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                int result = o1.getAge() - o2.getAge();
                if(result == 0){//若年龄一样，则按照姓名排序
                    result = o1.getName().charAt(0) - o2.getName().charAt(0);
                }
                return result;
            }
        });

可变参数-Java

可变参数

  • 使用前提

    当方法的参数列表数据类型已经确定，但是参数的个数不确定就可以使用可变参数

  • 使用格式

    修饰符 返回值 方法名称（数据类型…变量名）{ }

  • 原理

    可变参数的底层是一个数组，根据传递参数个数不同创建不同长度的数组，来存储这些参数。参数个数可以从0开始

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args) {
        System.out.println(add(1,2));
        int[]a = new int[]{1,2};
        System.out.println(add(a));
    }
public static int add(int...arr){
        //定义一个初始化变量累加
        int sum = 0;
        //遍历
        for (int i : arr) {
            sum += i;
        }
        return sum;
    }

  • 注意事项

    一个方法的参数列表只能有一个可变参数，如果方法的参数有多个，那么可变参数必须写在参数列表的末尾

泛型-Java

定义含有泛型的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class GenericClass <E> {
    E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}
 public static void main(String[] args) {
        GenericClass<String> gc = new GenericClass<>();
        gc.setName("hxx");
    }

定义含有泛型的方法

  • 修饰符 <泛型> 返回值类型 方法名(参数列表){ ………. }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class GenericClass{
   public <M> void method(M m){
       System.out.println(m);
   }
   public static <S> void methodB(S s){
   }
}
public static void main(String[] args) {
        GenericClass gc = new GenericClass();
        gc.method("hxx");
        gc.method(true);
        GenericClass.methodB("含有泛型的静态方法通过类名调用");
        
    }

含有泛型的接口

  • 修饰符 interface 接口名 <代表泛型的变量> { }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public interface GenericInterface<I> {
    public abstract void add(I e);
    public abstract I get();
}

public class GenericInterfaceImpl <E>implements GenericInterface <E> {

    @Override
    public void add(E e) {

    }

    @Override
    public E get() {
        return null;
    }
}
 public static void main(String[] args) {
        GenericInterfaceImpl<String> gcI = new GenericInterfaceImpl();
        gcI.add("hxx");
        System.out.println(gcI.get());
        GenericInterfaceImpl <Integer> gc2 = new GenericInterfaceImpl<>();
        gc2.add(100);
        System.out.println(gc2.get());
    }

泛型通配符<?>

  • 代表任意类型，不能定义时使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) {
        ArrayList<String>list1 = new ArrayList<>();
        list1.add("hxx");
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(22);
        printArray(list1);
        printArray(list2);
    }
    public static void printArray(ArrayList<?> list){
        //使用迭代器遍历
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

通配符高级使用–受限泛型

  • 泛型的上限：只接受该类型及其子类

    类型名 <? extends 类 > 对象名称

  • 泛型的下限：只接受该类型极其父类

    类型名 <? super 类 > 对象名称

集合框架Collection-Java

集合框架介绍

集合常用功能

  • public boolean add(E a):把给定的对象添加到集合当中
  • public void clear():清空元素
  • public boolean remove(E a)：删除指定元素
  • public boolean contains(E a)：查找是否包含a
  • public boolean isEmpty()
  • public int size()
  • public Object[] toArray()：把集合中的元素存储到数组中

迭代器Iterator接口

  • 常用方法

    public E next()：返回迭代的下一个元素

    public boolean hasNext()：如果有元素可以迭代，返回true

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
       Collection<String>collection = new ArrayList<>();
       collection.add("hxx");
       collection.add("qzy");
       //使用迭代器遍历
       Iterator<String> iterator = collection.iterator();//获取迭代器的实现类对象
       while (iterator.hasNext()){
           System.out.println(iterator.next());
       }
   }

增强for

  • 格式

    for(元素的数据类型 变量 ：Collection集合or数组){ ……… }

1
2
3
4
5
6
7
8
public static void main(String[] args) {
		ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("hxx");
        arrayList.add("qzy");
        for(String  s : arrayList){
            System.out.println(s);
        }
   }

日期时间类-Java

1. Date类

日期转换为毫秒

  • 获取当前系统时间到1970.1.1 08:00:00（中国）经历了多少毫秒

    1
    System.out.println(System.currentTimeMillis());

  • 将日期对象转换为毫秒

    1
    date.getTime()

Date类构造方法

  • Date date = new Date();//获取当前系统时间
System.out.println(date);

    1
    2
    3
    4
    5
    6
    7

    * 带参构造：传毫秒值

      ```java
      Date date1 = new Date(0);
      System.out.println(date1);
      //Thu Jan 01 08:00:00 CST 1970

SimpleDateFormat类

  • DateFormat是一个抽象类，无法直接创建对象使用，可以使用其子类SimpleDateFormat

  • 模式中常用格式规则：y(年)、M(月)、d(日)、H(时)、m(分)、s(秒)

    eg. yyyy-MM-dd HH:mm:ss 或者 yyyy年MM月dd日 HH时mm分ss秒

  • 格式化：按照指定的模式，将日期转换成文本String format （Date date） 

1
2
3
4
5
6
7
8
public static void main(String[] args) {
    	//指定模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //创建日期类
    	Date date = new Date();
    	//格式输出
        System.out.println(sdf.format(date));
    }
  • 解析：将符合模式的文本解析成日期Date parse（String source） ，若参数source不符合模式则会产生异常。
1
2
3
4
5
public static void main(String[] args) throws ParseException {
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
       Date date = sdf.parse("2020年08月21日 11时20分11秒");
       System.out.println(date);
   }

2. Calendar类

  • Calendar类是一个抽象类，里面提供了很多操作日历字段的方法(YEAR,MONTH,DAY_OF_MONTH,HOUR,MINUTE,SECOND）

  • Calendar类无法直接创建对象使用，里面有一个静态方法叫**getInstance()**，该方法返回了Calendar类的子类对象。

    static Calendar getInstance() 使用默认时区和语言环境获得一个日历 

1
2
Calendar calendar = Calendar.getInstance();//获取一个日历对象
System.out.println(calendar);

常用方法

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
       Calendar calendar = Calendar.getInstance();
       int year = calendar.get(Calendar.YEAR);
       System.out.println(year);
       calendar.set(Calendar.YEAR,1998);
       calendar.set(1998,7,1);
       calendar.add(Calendar.YEAR,-1);
       Date date = calendar.getTime();
   }

内部类-Java

概念和分类

  • 如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。

成员内部类

  • 基本格式

    修饰符 class 外部类名称{

    ​ 修饰符 class 外部类名称{
    ​ }

    }

  • 内部类可以随意访问外部类，外部类访问内部则需要内部类对象

  • 使用方式

    • 间接方式：在外部类的方法当中使用内部类；然后再main中调用外部类的方法

    • 直接方式：

      外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Myclass {//外部类
    private String name;
    public void method() {
        System.out.println("外部类的方法");
        MyInterClass myInterClass = new MyInterClass();
        myInterClass.beat();
    }
    public class MyInterClass {//成员内部类
        public void beat() {
            System.out.println("内部类的方法");
        }
    }
}
public static void main(String[] args) {
        Myclass myclass = new Myclass();
        myclass.method();
        Myclass.MyInterClass myInterClass = new Myclass().new MyInterClass();
        myInterClass.beat();
    }
  • 变量同名
1
2
3
4
5
6
7
8
9
10
11
12
public class Outer {
    int num = 30;
    public class Inter{
        int num = 20;
        public void method(){
            int num = 10;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Outer.this.num);
        }
    }
}

局部内部类（包括匿名内部类）

  • 定义在方法内部，只有当前所属的方法才可以用

  • 局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是有效final值

    原因：new出来的对象在堆内存中，局部变量随着方法存在栈内存中。方法运行结束之后，立刻出栈，局部变量就会立刻消失。但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

1
2
3
4
5
6
7
8
9
10
public class Outer {
    public void method(){
        final int num = 10;
        class Inter{
            public void methodInner(){
                System.out.println(num);
            }
        }
    }
}

匿名内部类

  • 如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，那么这种情况下可以省略点该类的定义，而改为使用匿名内部类

  • 定义格式

    接口名称 对象名 = new 接口名称(){

    //覆盖重写所有抽象方法

    }

1
2
3
4
5
6
7
8
9
10
11
12
public interface MyInterface {
    void method();
}
public static void main(String[] args) {
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名类");
            }
        };
    	obj.method();
    }

小节

  • 定义一个类的时候权限修饰符

    public > protected > (default) > private

    外部类：public / （default）

    内部类：public / protected / (default) / private

    局部内部类：什么都不写

final关键字-Java

final的概念和用法

  • final关键字代表最终、不可改变的

  • 可以用来修饰类、方法、局部变量、成员变量

final修饰类

  • 当前这个类不能有任何的子类，所以其所有的方法不能被覆盖重写。但是可以有父类

final修饰方法

  • 这个方法不能被覆盖重写
  • 对于类和方法来说，abstract关键字和final关键字不能同时使用。

final修饰局部变量

  • 一旦改变不能修改，只能一次赋值
  • 对于基本类型：变量的数据值不可改变
  • 对于引用类型：变量的地址值不可改变

final修饰成员变量

  • 由于成员变量具有默认值，所以使用final修饰之后必须手动赋值，可以直接赋值，也可以使用构造方法赋值（要保证所有的构造中都要赋值）。

多态-Java

格式和使用

  • 父类引用指向子类对象

    父类名称 对象名 = new 子类名称();

    接口名称 对象名 = new 实现类名称();

  • 访问成员变量的方式

    直接通过对象名称访问成员变量，优先等号左边，没有就向上找

    间接通过成员方法访问：（子类不重写时）同理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public  class Fu {
    int num = 20;
    public void method() {
        System.out.println("子类方法");
    }
}
public class Zi extends Fu {
    int num = 10;
    public void method() {
        System.out.println("子类方法");
    }
    public void methodA() {
        System.out.println("子类方法A");
    }
}
public static void main(String[] args) {
        Fu obj = new Zi();
        obj.method();
    	//obj.methodA();不能访问子类特有方法
        System.out.println(obj.num);
    }

运行结果

1
2
子类方法
20

对象的向上转型

  • 父类名称 对象名 = new 子类名称();

对象的向下转型

  • 子类名称 对象名 = (子类名称 ) 父类对象;
1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args) {
       giveMeAPet(new Zi());
    }
public static void giveMeAPet(Fu fu){
        if(fu instanceof Zi){
            Zi zi = (Zi)fu;
            zi.Mymethod();
        }
        if(fu instanceof ZiA){
            ZiA ziA=new ZiA();
            ziA.methodA();
        }
    }

接口-Java

命名规则

  • 接口是一种公共的规范标准，是一种引用数据类型。

  • 定义规则

    public interface 接口名称 { }

  • 接口内容可以包括：常量、抽象方法、默认方法、静态方法、私有方法等

  • 接口中的抽象方法，修饰符必须是public abstract，也可选择性的忽略

  • 接口没有静态代码块和构造方法

使用规则

  • 接口不能直接使用，必须有一个实现类来实现该接口。

  • 实现类必须覆盖重写接口的所有的抽象方法，如果没有全部实现，那么这个实现类必须是抽象类

    public class 实现类名称 implements 父类

1
2
3
4
5
6
7
8
9
10
11
12
13
public interface MyinterfaceAbs {
    public abstract void method();
}
public class Demo3Interface implements MyinterfaceAbs{
    @Override
    public void method() {
   		//。。。。。
    }
}
public static void main(String[] args) {
        Demo3Interface demo3Interface = new Demo3Interface();
        demo3Interface.method();
    }

默认方法

  • 当接口中新添加一个抽象方法时，会影响其他实现类。接口当中的默认方法可以解决接口升级的问题，默认方法会被实现类继承，也可被覆盖重写

    public default 返回值类型 方法名称（参数名称）{ 方法体 }

1
2
3
public default void methoddefault(){
        System.out.println("这是一个默认方法");
    }

静态方法

  • 不能通过接口实现类的对象来调用接口当中的静态方法，而是通过接口名称直接调用：接口名称.静态方法
  • public static 返回值类型 方法名称（参数名称）{ 方法体 }

私有方法

  • 当需要抽取一个公有方法，用来解决两个默认方法之间的重复代码的问题。但是这个代码不应该让实现类使用，应该是私有化的

  • 普通私有方法：解决多个默认方法之间重复代码问题

    private 返回值类型 方法名称（参数名称）{ 方法体 }

  • 静态私有方法：解决多个静态方法之间重复代码问题

    private static 返回值类型 方法名称（参数名称）{ 方法体 }

常量

  • 接口当中也可以定义“成员变量”，必须使用public static final来修饰，其实就是接口中的常量，一旦赋值不可修改。
  • 常量名称大写

继承父类实现多个接口

  • 一个类的直接父类是唯一的，但是一个类可以同时实现过个接口

    public interface 接口名称1，接口名称2…. { }

  • 若多个接口中同时定义了相同的抽象方法，那么实现类中覆盖重写一次即可

  • 若多个接口中同时定义了相同的默认方法，那么实现类中必须覆盖重写一次

  • 一个类，如果直接父类当中的方法和所实现接口当中的默认方法产生了冲突，优先使用父类当中的方法

接口和接口之间多继承

  • 多个父接口的抽象方法重复不影响
  • 多个接口的默认方法重复，那么子接口必须进行默认方法的覆盖重写，必须带default
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public interface MyinterfaceA {
    public abstract void methodA();
    public abstract  void methodCommon();
}
public interface MyinterfaceB {
    public abstract void methodB();
    public abstract  void methodCommon();
}
public interface Myinterface extends MyinterfaceA,MyinterfaceB{
    public abstract void method();
}
public class DemoMyinterface implements Myinterface{//实现四个抽象方法
    @Override
    public void methodA() {
    }
    @Override
    public void methodCommon() {
    }
    @Override
    public void methodB() {
    }
    @Override
    public void method() {
    }
}

接口 对象 = new 实现类 和 实现类 对象 = new 实现类的区别

  • 前提：接口A 类B是接口A的实现类

    A a = new B();

    B b = new B();

  • 区别

    a对象只能调用接口A中的方法，不能调用B中特有的方法；B可以调用接口和实现类中的特有方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    public interface SaleComputer {
        public void show();
    }
    public class Lenovo implements SaleComputer{
        @Override
        public void show() {
            System.out.println("展示电脑....");
        }
        public void myshow(){
            System.out.println("展示实现类的特有方法");
        }
    }
    public class ProxyTest {
        public static void main(String[] args) {
            //接口 = new 接口实现类
            SaleComputer temp = new Lenovo();
            temp.show();
            //实现类 对象 = new 实现类
            Lenovo lenovo = new Lenovo();
            lenovo.show();
            //调用实现类特有方法
            lenovo.myshow();      
        }
    }