SpringBoot课——Java语法（下）
SpringBoot课——Java语法（下）
函数
Java的所有变量和函数都要定义在类中。函数或变量前加
static表示静态对象，类似于全局变量。 静态对象属于class，而不属于class的具体实例。静态函数中只能调用静态函数和静态变量。
静态变量绑定到类上面 ，普通变量绑定到具体实例上面。
示例：
import java.util.Arrays; public class Main { public static void main(String[] args) { System.out.println(max(3, 4)); int[][] a = new int[3][4]; fill(a, 3); System.out.println(Arrays.deepToString(a)); int[][] b = getArray2d(2, 3, 5); System.out.println(Arrays.deepToString(b)); } private static int max(int a, int b) { if (a > b) return a; return b; } private static void fill(int[][] a, int val) { for (int i = 0; i < a.length; i ++ ) for (int j = 0; j < a[i].length; j ++ ) a[i][j] = val; } private static int[][] getArray2d(int row, int col, int val) { int[][] a = new int[row][col]; for (int i = 0; i < row; i ++ ) for (int j = 0; j < col; j ++ ) a[i][j] = val; return a; } }package com.dragon; import java.util.Scanner; //函数 class Point{ private int x; //私有变量 所有实例私有的变量 private static int y; //共有变量 所有实例共用的变量 public int f(){ //普通函数 相当于实例化a,b,c 每个自己独有的函数 return 0; } public static int g(){ //加上static 类似于全局函数 绑定到 Point 类本身 //static 静态函数里 只能调用静态变量和静态函数 //System.out.println(x); 报错 y = 100; System.out.println(y); return 0; } } public class hanshu { public static void main(String[] args) { //public 是所有类都可以访问 Scanner sc = new Scanner(System.in); Point a,b,c; //实例 共用 static 的函数 int m = sc.nextInt(),n = sc.nextInt(); System.out.println(max(m,n)); } //函数 private static int max(int x,int y){ //private 只有这个类内部可以访问 return Math.max(x,y); } } 注
Java同样支持问号表达式
return a > b ? a : b;
包
包（package）是Java实现类的分类组织的手段。创建一个类之前，需要明确准备在哪个包里创建类。可以在无名包（即项目文件夹java）里创建类，也可以在一个已有包（即项目文件夹java的某个子文件夹）里创建类，还可以新建包（在项目文件夹java或在某个包下再创建子包）、并在新包里创建类。
package zcst; public class Stuff{ }在定义类Stuff的关键字class前，默认使用了访问控制符public，表示该类是公有的，即项目里的其他类（无论在哪个包）都可以访问公有类Stuff。
IDEA里创建包，允许创建带点“.”的多级包名。例如，在项目文件夹java里创建名为zcst.cs.hlb的包时，包名显示默认为紧凑格式。单击项目窗口里的工具
，在弹出的选项中，单击【Compact Middle Packages】后，将以分层缩进格式显示包名。
在类体里，可以定义字段（也称域变量或成员变量）或方法作为成员。此外，还可以定义一个类（称为内部类）作为成员。在方法体里定义的变量称为局部变量。
对象是类的实例，通常使用运算符new创建。
修饰符
Java语言提供了很多修饰符，用来修饰类、字段、方法和内部类，通常放在语句的最前端。
修饰符分为访问修饰符和非访问修饰符两大类。
访问修饰符
访问修饰符用于设置类或类成员（方法、字段或内部类）的访问权限，类及类成员的访问权限取决于访问控制符和它所在的包。
Java的访问修饰符有public、protected、default（即没有访问修饰符）和private共四种。
其中，default对应于包访问权限（即可被同一包内的元素访问）
非访问修饰符
类及其成员除了需要考虑可见性外，还需要考虑生命周期和作用域等问题。为此， Java提供了三种非访问修饰符。
使用关键字
**static**修饰的成员变量，称为静态成员变量，也称类变量。静态成员变量（简称静态变量）在类加载时被初始化，并存放在内存静态存储区，可以直接通过“类名.变量名”直接访问，也可以通过类的对象访问。static修饰的成员为类所有，优先于对象的构造方法被执行，同一类型的局部变量的不同对象共享此成员 。没有使用static修饰的成员变量（简称实例变量）在对象创建时被实例化，存放在堆内存，可能作为垃圾被回收。
注意：
（1）静态变量（方法）与类相关，实例变量（方法）与对象相关。
（2）实例变量和静态变量定义的位置，都在类的方法体之外。
使用final 修饰的类称为终结类，不能够被继承。使用final修饰的方法可以被继承，但不能被子类重新定义（覆盖或重写）。使用final修饰的变量是不可修改的常量。
使用abstract创建抽象类和抽象方法。
类
承前所述，类是一组对象的模板，是各种共性特征和动作的集合。其中，用来刻画类的某一方面的静态特征被称为属性，也即成员变量。Java中的成员变量根据不同的修饰符修饰有三种类型：静态变量、实例变量和常量。
刻画类的动作行为被称为方法。Java中的方法分为构造方法和普通的方法，其中构造方法用于创建类的对象，此时由系统自动调用，用来给出对象的初始状态。在有参数的构造方法中，为了区分同名的形参，需要使用this关键字访问同名属性。
普通的方法用来实现对象的某种功能，普通方法也有类方法(即静态方法)和实例方法之分。类方法可以在对象创建之前通过类名直接调用，所以this不能出现在类方法中。
类的构造方法
一个类的构造方法不同于普通方法，主要表现在以下几个方面：
（1）构造方法的方法名与类名相同；
（2）构造方法没有返回值，也没有返回类型，也不被继承；
（3）一个类可以有多个构造方法，允许0个、1个或多个参数。系统默认提供一个无参构造方法，但是如果用户定义了任意一个构造方法，系统将不再提供默认无参构造方法。而且，调用构造方法创建对象时总是调用一个匹配的构造方法，如果找不到一个这样的构造方法，系统将报错；
（4）构造方法的主要作用是完成对类的对象的初始化工作，在创建一个类的对象时，一般地由系统自动调用该类的构造方法为对象初始化。
当创建一个对象时，Java会逐级向上调用其父类的构造方法，然后对对象的各个变量设置默认的初始值。
构造方法具体的执行顺序是：
（1）调用父类的构造方法，这个过程会重复下去，直到Java顶层类Object；
（2）按变量声明或定义顺序，对成员变量进行初始化；
（3）执行构造方法中的各语句。
构造方法调用的顺序保证所有的父类构造方法都得到调用，保证其基类的成员得到正确的初始化并执行相关语句，然后对本对象的变量进行初始化。如果在一个类中，既有静态变量和实例变量定义，又有静态代码块和非静态代码块，它们和构造方法的执行顺序孰先孰后？答案是：
(静态变量、静态初始化块) > (实例变量、非静态初始化块) > 构造方法
在类的成员变量和方法也可以使用访问修饰符和非访问修饰符。属性一般使用private修饰，方法使用public修饰。
下面举例说明类中这些“元素”的用法。
类的构造方式与this关键字
类的构造方法，用于创建类的实例（即对象）并初始化成员字段。在创建对象时，会自动调用类的构造方法。 构造方法名必须与类名相同，并且没有返回类型。另外，构造方法一般使用public修饰，以保证在类的外部能创建类的实例。
对象的创建语法是：
类名 对象名 = new 构造方法名([参数表]);
赋值语句右边的new是为新建对象开辟内存空间的运算符，这些内存空间保存对象的成员变量和成员方法。用new运算符开辟新建对象的内存之后，系统自动调用构造方法初始化该对象。
当类中未定义构造方法时，编译系统会自动添加一个无参构造方法。当定义了有参构造方法时，编译系统不再提供无参构造方法。
Java关键字this用来表示对当前类的对象的引用。例如，当方法参数和成员变量同名时，通过前缀“this.”来表明是使用类的成员变量。若类的成员字段与方法参数同名，则需要使用this关键字解决命名冲突问题。
类与接口
类
class与C++、Python类似。
class源文件声明规则
一个源文件中只能有一个
public类。一个源文件可以有多个非
public类。源文件的名称应该和
public类的类名保持一致。每个源文件中，先写
package语句，再写import语句，最后定义类。类的定义
public: 所有对象均可以访问
private: 只有自己可以访问
class Point { private int x; private int y; public Point(int x, int y) { this.x = x; this.y = y; } public void setX(int x) { this.x = x; } public void setY(int y) { this.y = y; } public int getX() { return x; } public int getY() { return y; } public String toString() { return String.format("(%d, %d)", x, y); } }类的继承
每个类只能继承一个类。
class ColorPoint extends Point { private String color; public ColorPoint(int x, int y, String color) { super(x, y); this.color = color; } public void setColor(String color) { this.color = color; } public String toString() { return String.format("(%d, %d, %s)", super.getX(), super.getY(), this.color); } } 类的多态
public class Main { public static void main(String[] args) { Point point = new Point(3, 4); Point colorPoint = new ColorPoint(1, 2, "red"); // 多态，同一个类的实例，调用相同的函数，运行就结果不同 System.out.println(point.toString()); System.out.println(colorPoint.toString()); } }
抽象类
抽象类是使用abstract修饰的类。抽象类必须被继承，也不能被实例化，即没有具体实例对象，需要派生出子类后才能创建子类的对象。**抽象类在代码实现方面发挥作用，可以实现代码的重用。**
抽象类往往被设计成较高层次的基类或“顶层”类，其中可以实现一些方法，给出公共的行为功能，也可以声明为抽象方法，留给子类实现。
抽象类可以继承另一个抽象类，还可以实现接口，因为抽象类允许方法的实现。
定义抽象类
定义抽象类的子类
测试类（文件名AbstractDemo.java里包含上面的2个类。其中，上面的2个类不能使用public修饰）
说明：
（1）Java运行时系统根据调用该方法的对象，来决定调用哪个方法。对于子类的一个对象，如果子类重写了父类的方法，则运行时系统调用子类的方法；如果子类继承了父类的方法（未重写），则运行时系统调用父类的方法。
（2）对象animal.eat()因animal指向不同的子类对象而呈现不同的行为，即运行时的动态绑定，称为多态。
多态
多态（polymorphism）指同一类对象在不同的情况下所表现出来的不同状态，它是面向对象程序设计（OOP）的一个重要特征。如果一种程序设计语言只支持类而不支持多态，只能说明它是基于对象的，而不是面向对象的。
由方法重载（Overloading）实现的静态多态性称为编译时多态。在编译阶段，编译器会根据参数类型及个数的不同来静态确定调用相应的方法。
由方法覆盖（Overriding）实现的动态多态性称为运行时多态。Java运行时系统会根据对象的实际类型动态地调用父类方法或者同名的子类方法。前面关于抽象类和接口的例子表明，抽象类和接口都能实现多态。
在类继承体系中，子类也可以直接定义与父类同样的属性进行属性覆盖（或称变量覆盖），这也是多态性的表现。只要属性可见且名称相同，就可实现属性覆盖。一个属性覆盖的示例如下：
属性可以被子类中的同名变量所覆盖，也可以被继承。当然，private类型的属性除外。
内部类
定义在一个类的类体中的类被称为内部类，包含内部类的类称为内部类的外部类。外部类可以把内部类声明成对象作为外部类的成员，内部类中的方法可以访问外部类中的成员变量和方法。内部类还有静态内部类和匿名内部类等形式，有以下定义方式：作为其它类的成员、在一个语句块的内部定义、在表达式内部匿名定义。内部类具有以下特点：
一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称，名字不能与包含它的类名相同。编译后生成“外部类名称$内部类名称.class”文件。
可以使用包含它的外部类的静态和实例成员变量，也可以使用它所在方法（或语句块）的final局部变量。
非访问修饰符可以声明为static, final及abstract。
访问修饰符可以声明为public，protected，private及默认。
若被声明为static，就变成了顶层类。因为它们的存在不依赖于外部类的一个对象。
若想在内部类中声明任何static成员，则该内部类必须声明为static。
内部类更多的反映的是类/对象之间的关系。内部类一般用来生成事件适配器，用于事件处理。
匿名内部类
匿名类就是没有名字的内部类，把继承类与实例化子类对象压缩在一个表达式里面。
内部类能够访问外部类的一切成员变量和方法，包括私有的，而实现接口或继承类却做不到
使用匿名内部类可使代码更加简洁、紧凑，模块化和程度更高。内部类能够访问外部类的一切成员变量和方法，包括私有的，而实现接口或继承类却做不到。
匿名内部类有两种实现方式：
第一种，继承一个类，重写其方法；
第二种，实现一个接口（可以是多个），实现其方法。
当您创建一个匿名类时，它是一个新的“无名称”类，它扩展了抽象类（或实现了接口）并被实例化。
例如
乍一看，以为main方法中实例化了此抽象类，其实不然！仔细体味发现，这里new语法和普通的对象实例化的写法不同，后面带有一对{}。为什么可以这么写呢？实际上，这个写法是匿名内部类的使用方法。匿名类是没有有名称的类，创建时，使用new语句的一部分来声明。因此，上面的代码其实声明了一个匿名内部类，然后这个匿名内部类继承了抽象类absClass。因此{}中可以写这个类的实现细节。
absClass ac = new absClass(){}; //匿名内部类的使用方法
静态内部类
被声明为静态的内部类自动地成为顶层类。静态内部类不能访问外部类的非静态成员，但可以声明静态成员变量和方法。
静态内部类实际是一种外部类(顶层类)，可以直接作为一个普通类来使用，因为它们的存在不需要实例化外部类。创建静态内部类对象时可以一次完成! 即不需要外部类对象的引用，例如：
外部类.静态内部类 sinnx= new 外部类.静态内部类();
可以进一步简化为：静态内部类 sinnx=new 静态内部类();
类 类型信息和反射
我们知道在Java中，使用运算符new创建对象，但这不是唯一方式。
JDK提供了另一种创建对象的方法，即Java虚拟机在运行时通过反射机制创建类的对象。
通过反射机制，还可以调用类的私有方法，修改final类型变量。
接口 ——— 用来规范 类
interface与class类似。主要用来定义类中所需包含的函数。
接口也可以继承其他接口，一个类可以实现多个接口。
接口的定义
interface Role { public void greet(); public void move(); public int getSpeed(); //使用了接口的，都有这些方法 //使用接口的对象中这些方法必须要实现，不然编译器会报错 强制性，用来规范 类 }用来规范 某些类必须要实现的函数
接口的继承
每个接口可以继承多个接口
类不可以继承多个类
interface Hero extends Role { public void attack(); }接口的实现
每个类可以实现多个接口
class Zeus implements Hero { //IDEA 中使用 Alt + Enter 可以快速生成需要实现的接口 private final String name = "Zeus"; public void attack() { System.out.println(name + ": attack!"); } public void greet() { System.out.println(name + ": Hi!"); } public void move() { System.out.println(name + ": Move!"); } public int getSpeed() { return 10; } }IDEA 中使用 Alt + Enter 可以快速生成需要实现的接口
当一个类实现了某个接口时，这个类也会附到这个接口上——以至于可以替换 定义前面的类型
interface Role{ public void greet(); public void move(); public int getSpeed(); } interface Role2{ } //接口的继承 接口可以继承多个接口 类不可以继承多个类 interface Hero extends Role,Role2{ public void attack(); } //实现接口 class Zous implements Hero{ // IDEA 中使用 Alt + Enter 可以快速生成需要实现的接口 private final String name = "Zous"; public void greet(){ System.out.println(name +": Hi!"); } public void move(){ System.out.println(name + ": Move!"); } public int getSpeed(){ return 10; } public void attack(){ System.out.println(name + ": Attack!"); } } Zous zous = new Zous(); //当一个类实现了某个接口时，这个类也会附到这个接口上 Hero zous2 = new Zous(); //以至于可以替换 定义前面的类型 Role zous3 = new Zous(); // zous3.attack(); Role接口中没有attack这个方法 ，所以不能使用这个方法 zous3.move();接口的多态
interface Role{ public void greet(); public void move(); public int getSpeed(); } interface Role2{ } //接口的继承 接口可以继承多个接口 类不可以继承多个类 interface Hero extends Role,Role2{ public void attack(); } //实现接口 class Zous implements Hero{ // IDEA 中使用 Alt + Enter 可以快速生成需要实现的接口 private final String name = "Zous"; public void greet(){ System.out.println(name +": Hi!"); } public void move(){ System.out.println(name + ": Move!"); } public int getSpeed(){ return 10; } public void attack(){ System.out.println(name + ": Attack!"); } } //接口的多态 class Athena implements Hero{ // IDEA 中使用 Alt + Enter 可以快速生成需要实现的接口 private final String name = "Athena"; public void greet(){ System.out.println(name +": Hi!"); } public void move(){ System.out.println(name + ": Move!"); } public int getSpeed(){ return 10; } public void attack(){ System.out.println(name + ": Attack!"); } } public class JieKo { public static void main(String[] args) { //使用 Zous zous = new Zous(); //当一个类实现了某个接口时，这个类也会附到这个接口上 zous.greet(); zous.attack(); Hero zous2 = new Zous(); //以至于可以替换 定义前面的类型 Role zous3 = new Zous(); // zous3.attack(); Role接口中没有attack这个方法 ，所以不能使用这个方法 zous3.move(); //接口的多态 // 例如 选择英雄 Zous or Athena Scanner sc = new Scanner(System.in); System.out.println("请选择英雄！Zous or Athena"); String name =sc.next(); Hero hero; if("Zous".equals(name)){ hero = new Zous(); }else{ hero = new Athena(); } hero.greet(); //接口的多态 代码整洁 代码重用 //请选择英雄！Zous or Athena // Athena //Athena: Hi! } }
hero.greet(); //接口的多态 代码整洁 代码重用接口的多态 可以使得代码重用 代码更加简洁
泛型
类似于C++的template，Java的类和接口也可以定义泛型，即同一套函数可以作用于不同的对象类型。 泛型只能使用对象类型，不能使用基本变量类型。
例如
import java.util.Stack; //z public class Main{ public static void main(String[] args){ Stack<Integer> stk = new Stack<Integer>(); //尖括号是泛型 //Integer 是 int 的对象形式 } }
常用容器
List
List是一个接口
接口：
java.util.List<>import java.util.List;该接口有两个不同的实现方式：
java.util.ArrayList<>：变长数组
java.util.LinkedList<>：双链表函数:
add()：在末尾添加一个元素
clear()：清空
size()：返回长度
isEmpty()：是否为空
get(i)：获取第i个元素
set(i, val)：将第i个元素设置为val
示例：
package com.dragon.ChangYongJieKo; import java.util.ArrayList; import java.util.LinkedList; public class List { public static void main(String[] args) { //两种实现方式 java.util.List<Integer> list = new ArrayList<>(); //如果有大量的随机存写操作 用ArrayList(变长数组)实现 java.util.List<Integer> list2 = new LinkedList<>(); //如果有大量的中间的添加删除操作，可以用LinkedList(双链表)实现 //函数 list.add(1); //添加元素 list.add(2); System.out.println(list); System.out.println(list.size()); //返回长度 System.out.println(list.get(1)); //获取第2个元素 ————注意序号是从0开始计数的 System.out.println(list.set(0,233)); //把第1个元素 设置成 233 list.clear(); //清空元素 System.out.println(list); System.out.println(list.isEmpty()); //是否为空 //输出 //[1, 2] //2 //2 //1 //[] //true } }栈
栈是一个类
类：
java.util.Stack<>函数：
push()：压入元素
pop()：弹出栈顶元素，并返回栈顶元素
peek()：返回栈顶元素
size()：返回长度
empty()：栈是否为空
clear()：清空
示例：
package com.dragon.ChangYongJieKo; import java.util.Stack; public class Zhan { public static void main(String[] args) { //栈的初始化 栈是一个类 Stack<Integer> stk = new Stack<>(); //栈的初始化 Integer 是 int 的对象类型 stk.push(1); //压栈 压入元素 stk.push(3213); System.out.println(stk); //[1, 3213] System.out.println(stk.peek()); //仅返回栈顶元素 System.out.println(stk.pop()); //弹出栈顶元素，并返回栈顶元素 System.out.println(stk); //查询出栈后的剩余元素 System.out.println(stk.empty()); //查询栈是否为空 stk.clear(); //清空栈 System.out.println(stk.empty()); //查询栈是否清空 //输出结果 //[1, 3213] //3213 //3213 //[1] //false //true } }队列
队列是一个接口
接口：
java.util.Queue<>实现：
java.util.LinkedList<>：双链表
java.util.PriorityQueue<>：优先队列 默认是小根堆，大根堆写法：new PriorityQueue<>(Collections.reverseOrder())函数：
add()：在队尾添加元素
remove()：删除并返回队头
isEmpty()：是否为空
size()：返回长度
peek()：返回队头
clear()：清空
示例：
package com.dragon.ChangYongJieKo; import java.util.Collections; import java.util.LinkedList; import java.util.PriorityQueue; import java.util.Queue; public class Duilie { public static void main(String[] args) { //队列 是一个接口 //队列有两种实现方式 Queue<Integer> q = new LinkedList<>(); //双链表实现 Queue<Integer> qq = new PriorityQueue<>(); //优先队列 实现 默认是小根堆 //优先队列 是堆 Queue<Integer> qqq = new PriorityQueue<>(Collections.reverseOrder()); //优先队列 大根堆 写法 q.add(1); q.add(2); //在队尾添加元素 System.out.println(q); System.out.println(q.size()); //返回长度 System.out.println(q.remove()); //删除并返回队头 System.out.println(q.isEmpty()); //查询是否为空 System.out.println(q.size()); //返回长度 System.out.println(q.peek()); //返回队头 q.clear(); //清空 System.out.println(q.isEmpty()); //输出为: //[1, 2] //2 //1 //false //1 //2 //true //优先队列演示 qq.add(5); qq.add(3); qq.add(4); System.out.println(qq); //[3, 5, 4] System.out.println(qq.peek()); //队头为 3 qq.remove(); System.out.println(qq.peek()); //队头为 4 } }Set 集合
Set 是一个接口
接口：
java.util.Set<K>实现：
java.util.HashSet<K>：哈希表 哈希表 无序的集合
java.util.TreeSet<K>：平衡树 有序的集合函数：
add()：添加元素
contains()：是否包含某个元素
remove()：删除元素
size()：返回元素数
isEmpty()：是否为空
clear()：清空
java.util.TreeSet多的函数：
注意 使用下面两个函数 初始化语句需要改变
TreeSet<Integer> settt = new TreeSet<>();ceiling(key)：返回大于等于key的最小元素，不存在则返回null
floor(key)：返回小于等于key的最大元素，不存在则返回null
示例：
package com.dragon.ChangYongJieKo; import java.util.HashSet; import java.util.Set; import java.util.TreeSet; public class Set1 { public static void main(String[] args) { // Set 集合 //两种实现方式 Set<Integer> set = new HashSet<>(); //哈希表实现 无序的集合 Set<Integer> sett = new TreeSet<>(); //平衡树实现 有序的集合 set.add(4); set.add(1); set.add(2); set.add(1); //重复的数据会被自动剔除 System.out.println(set); //[1,2] System.out.println(set.contains(3)); //是否包含某个元素 System.out.println(set.contains(2)); set.remove(2); //删除某个元素 System.out.println(set.size()); //返回元素数 System.out.println(set.isEmpty()); //是否为空 set.clear();//清空 System.out.println(set.isEmpty()); //java.util.TreeSet多的函数： TreeSet<Integer> settt = new TreeSet<>(); settt.add(4); settt.add(1); settt.add(5); settt.add(2); System.out.println(settt); System.out.println(settt.ceiling(3)); //返回大于等于 3 的最小元素 ，如果不存在则返回 null System.out.println(settt.floor(3)); //返回小于等于 3 的最大元素 ， 如果不存在则返回 null System.out.println(settt.ceiling(6)); System.out.println(settt.floor(0)); //输出： //[1, 2, 4] //false //true //2 //false //true //[1, 2, 4, 5] //4 //2 //null //null } }Map 集合映射
Map 是接口
接口：
java.util.Map<K, V>实现：
java.util.HashMap<K, V>：哈希表
java.util.TreeMap<K, V>：平衡树函数：
put(key, value)：添加关键字和其对应的值
get(key)：返回关键字对应的值
containsKey(key)：是否包含关键字
containsValue(Value): 是否包含某个值
remove(key)：删除关键字
size()：返回元素数
isEmpty()：是否为空
clear()：清空
entrySet()：获取Map中的所有对象的集合
Map.Entry<K, V>：Map中的对象类型
getKey()：获取关键字
getValue()：获取值
java.util.TreeMap<K, V>多的函数：
ceilingEntry(key)：返回大于等于key的最小元素，不存在则返回null
floorEntry(key)：返回小于等于key的最大元素，不存在则返回null
示例：
package com.dragon.ChangYongJieKo; import java.util.HashMap; import java.util.Map; import java.util.TreeMap; public class Map1 { public static void main(String[] args) { // Map 是接口 集合映射 Map<Integer,String> map = new HashMap<>(); //第一种实现 哈希表 Map<Integer,String> mapp = new TreeMap<>(); //第二种实现 平衡树 map.put(2,"abc"); //put 添加关键字和其对应的值 map.put(5,"dragon"); map.put(3,"ewd"); System.out.println(map); //{2=abc, 3=ewd, 5=dragon} System.out.println(map.get(5)); //获取 5 对应的值 System.out.println(map.containsKey(3)); //是否包含某个关键字 System.out.println(map.containsValue("awd")); //是否包含某个值 map.remove(3); //删除某个关键字 System.out.println(map.containsKey(3)); System.out.println(map); System.out.println(map.size()); //查询map中的元素数 System.out.println(map.entrySet()); //返回所有键值对的集合 [2=abc, 5=dragon] //Map 的遍历 for (Map.Entry<Integer,String> p: map.entrySet()){ System.out.println(p.getKey() + " " + p.getValue()); } //2 abc //5 dragon System.out.println(map.isEmpty()); //查询map是否为空 map.clear(); //清空map System.out.println(map.isEmpty()); //java.util.TreeMap<K, V>多的函数： TreeMap<Integer,String> mappp = new TreeMap<>(); mappp.put(2,"abc"); mappp.put(5,"dragon"); mappp.put(3,"ewd"); Map.Entry<Integer,String > up =mappp.ceilingEntry(4); //返回大于等于key的最小元素，不存在则返回null System.out.printf("%d %s \n",up.getKey(),up.getValue()); Map.Entry<Integer,String> down = mappp.floorEntry(4); //返回小于等于key的最大元素，不存在则返回null System.out.printf("%d %s \n",down.getKey(),down.getValue()); //5 dragon //3 ewd //结果为： //{2=abc, 3=ewd, 5=dragon} //dragon //true //false //false //{2=abc, 5=dragon} //2 //[2=abc, 5=dragon] //2 abc //5 dragon //false //true //5 dragon //3 ewd } }
