Java的输入和输出

一、输出语句

1.System.out.print() 不换行直接输出

2. System.out.println()输出后会自动换行

3. System.out.printf()按格式输出

//%表示进行格式化输出，%之后的内容为格式的定义
格式控制符			说明
--------------------------------------------------
	%d			输出int型数据
	%c			输出char型数据
	%f			输出浮点型数据，小数部分最多保留6位
	%s			输出字符串数据
	%md			输出的int型数据占m列
	%m.nf		输出的浮点型数据占m列，小数点保留n位

示例：

public class out{
    public static void main(String[] args) {
        System.out.print("hello");
        System.out.println("hello world");
        int m=16;
        System.out.printf("这是 %d", m);
        System.out.println();
        double n=3.25446;
        System.out.printf("%d  %.2f", m,n);
    }
}

输出：

二、输入语句

键盘输入代码的四个步骤:

1、导包：import java.util.Scanner;

2、创建Scanner类型的对象：Scanner scanner= new Scanner( System.in) ;

3、调用Scanner类的相关方法(next() / nextXxx()) ，来获取指定类型的变量

4、释放资源：调用Scanner对象的close()方法， scanner.close();

1. 基础用法

import java.util.Scanner;

public class in {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("Please enter your name:");
        String s=in.next();
        System.out.printf("Your name is %s",s);
        in.close();
    }
    
}

输出：

2. 标准写法

先判断是否还有输入，再输入

import java.util.Scanner;

public class in {
    public static void main(String[] args) {
        //2、定义一个Scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：" );//输出提示信息
        //3、调用Scanner类的相关方法next方式接收字符串
        if(scanner.hasNext()){// 判断是否还有输入
            String str1 = scanner.next();
            System.out.println("输入的数据为：" + str1);
        }
        //4、释放资源：调用Scanner对象的close()方法， `scanner.close();`
        scanner.close();
    }
}

输出：

3. String类型字符串的输入

3.1 next方法

next()只会读取第一个字符串，空格后的字符不读取。

import java.util.Scanner;

public class in {
    public static void main(String[] args) {
        //2、定义一个Scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：" );//输出提示信息
        //3、调用Scanner类的相关方法next方式接收字符串
        if(scanner.hasNext()){// 判断是否还有输入
            String str1 = scanner.next();
            System.out.println("输入的数据为：" + str1);
        }
        //4、释放资源：调用Scanner对象的close()方法， `scanner.close();`
        scanner.close();
    }
}

输出：

3.2 nextLine()方法

读取一整行的输入。

import java.util.Scanner;

public class in {
    public static void main(String[] args) {
        //2、定义一个Scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：" );//输出提示信息
        //3、调用Scanner类的相关方法next方式接收字符串
        if(scanner.hasNextLine()){// 判断是否还有输入
            String str1 = scanner.nextLine();
            System.out.println("输入的数据为：" + str1);
        }
        //4、释放资源：调用Scanner对象的close()方法， `scanner.close();`
        scanner.close();
    }
}

输出：

原文链接:Java016------Java输入输出语句_java输出-CSDN博客

三、常见类型的转化

1. 数字的字符串转换为整数类型

String numberStr = "123";
int number = Integer.parseInt(numberStr);

2. 整数转换为字符串类型

int number = 123;
String numberStr = Integer.toString(number);
// 或者
String numberStr = String.valueOf(number);

3.字符串转换为字符数组

String str = "hello";
char[] charArray = str.toCharArray();

4. 字符数组转字符串

char[] charArray = {'h', 'e', 'l', 'l', 'o'};
String str = new String(charArray);
// 或者
String str = String.valueOf(charArray);

5. 进制间的互相转换

public class BaseConversion {
    public static void main(String[] args) {
        // Decimal to Binary
        int decimal1 = 10;
        String binary = Integer.toBinaryString(decimal1);
        System.out.println("Decimal: " + decimal1 + " to Binary: " + binary);

        // Binary to Decimal
        String binaryStr = "1010";
        int decimalFromBinary = Integer.parseInt(binaryStr, 2);
        System.out.println("Binary: " + binaryStr + " to Decimal: " + decimalFromBinary);

        // Hex to Decimal
        String hexStr = "A";
        int decimalFromHex = Integer.parseInt(hexStr, 16);
        System.out.println("Hex: " + hexStr + " to Decimal: " + decimalFromHex);

        // Decimal to Hex
        int decimal2 = 10;
        String hex = Integer.toHexString(decimal2);
        System.out.println("Decimal: " + decimal2 + " to Hex: " + hex);
    }
}

输出：

Decimal: 10 to Binary: 1010
Binary: 1010 to Decimal: 10
Hex: A to Decimal: 10
Decimal: 10 to Hex: a

如果数字很大，可以用BigInteger类实现

import java.math.BigInteger;

public class BaseConversion {
    public static void main(String[] args) {
        // Decimal to Binary
        BigInteger decimal1 = new BigInteger("123456789012345678901234567890");
        String binary = decimal1.toString(2);
        System.out.println("Decimal: " + decimal1 + " to Binary: " + binary);

        // Binary to Decimal
        String binaryStr = "110110101010110110111110111011101110111011101110111";
        BigInteger decimalFromBinary = new BigInteger(binaryStr, 2);
        System.out.println("Binary: " + binaryStr + " to Decimal: " + decimalFromBinary);

        // Hex to Decimal
        String hexStr = "1A2B3C4D5E6F";
        BigInteger decimalFromHex = new BigInteger(hexStr, 16);
        System.out.println("Hex: " + hexStr + " to Decimal: " + decimalFromHex);

        // Decimal to Hex
        BigInteger decimal2 = new BigInteger("123456789012345678901234567890");
        String hex = decimal2.toString(16);
        System.out.println("Decimal: " + decimal2 + " to Hex: " + hex);
    }
}

四、switch语法

在switch语法中，switch()圆括号中写入判断的数字，当case语句的值等于圆括号内的值时，将执行相应代码块的代码。

每段case语句后需要跟一个break语句结束，否则将继续进行下一个case语句内。且default语句不能直接触发，当switch内的值与case值均不匹配时，将会执行default内的代码语句。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String grade =scanner.next();
        switch(grade){
            case "A":
                System.out.print("优秀");
                break;
            case "B":
                System.out.print("良好");
                break;
            case "C":
                System.out.print("及格");
                break;
            case "D":
                System.out.print("不及格");
                break;
            default:System.out.print("未知等级");
        }

    }
}

五、求两个整数的最小公倍数和最大公因子

1.最小公倍数

最大公倍数一定在a,b较大数和它们的乘积之间，在该区间从小到大遍历找到能整除a,b的数即为答案。

public class Main {
    public static void main(String[] args) {
        //标准输入
        Scanner console = new Scanner(System.in);
        int m = console.nextInt();
        int n = console.nextInt();
        //计算最小公倍数
        int result = getCM(m, n);
        //输出结果
        System.out.println(result);
    }
 
    //计算最小公倍数
    public static int getCM(int m, int n){
        //计算m、n中较大者
        int max=Math.max(m,n);
        //从max到m*n之间找最小公倍数
        for(int i=max;i<=m*n;i++){
            //如果既能被m整除又能被n整除，说明是最小公倍数，直接返回
            if(i%m==0&&i%n==0){
                return i;
            }
        }
        return -1;
    }
     
}

2. 最大公因子

可以利用辗转相除，a,b的最大公约数等于较小值和较大值对小值取余得到的余数的最大公约数。

 public static int get(int m, int n){
        int a=m>n?m:n;
        int b=m<=n?m:n;
        int s=m*n;
        int c=a%b;
        while(c!=0){
            a=b;
            b=c;
            c=a%b;            
        }
        return b;

    }

六、数组的复制

1.System.arraycopy()

Java提供了System类中的arraycopy()方法来实现数组复制。这个方法能够以更高效的方式复制数组，因为它是通过底层的本地代码实现的。下面是使用arraycopy()方法的示例代码：

int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = new int[sourceArray.length];

System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);

2. Arrays.copyOf()

int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = Arrays.copyOf(sourceArray, sourceArray.length);

3.Arrays.copyOfRange()

copyOfRange方法有以下几个重载的方法，使用方法基本一样，只是参数数组类型不一样
original：第一个参数为要拷贝的数组对象
from：第二个参数为拷贝的开始位置（包含）
to：第三个参数为拷贝的结束位置（不包含）

七、对象相关

1. 获取类名

• getClass() 方法是 Object 类的一个方法，用于获取对象所属的类的 Class 对象。Class 类包含有关类的结构信息，包括类的名称、字段、方法等。因此，getClass() 方法返回的是调用该方法的对象所属的类的 Class 对象。
• getName() 方法是 Class 类的一个方法，用于获取类的规范化名称。对于类来说，这个名称包括包名和类名，例如 "java.lang.String"。对于数组类来说，这个名称包括元素类型的名称和一个或多个括号，例如 "int[]"。所以，getName() 方法返回的是调用该方法的 Class 对象所表示的类的名称。

import java.util.Scanner;

public class  test_class{
    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String className = scanner.next();
            //Class.forName(className) 通过类的完整名称动态加载类，返回一个 Class 对象
            System.out.println(Class.forName(className));
            //newInstance() 方法创建了 Class 对象所表示的类的一个新实例
            print(Class.forName(className).newInstance());
        }
    }
    public static void print(Object obj){
        System.out.println(obj.getClass().getName()); //调用getName函数直接输出
    }
 
}  
class First {
    public String toString() {
        return "this is First";
    }
}

class Second {
    public String toString() {
        return "this is Second";
    }
}

class Third {
    public String toString() {
        return "this is Third";
    }
}

2. 实现抽象方法(extends)

public class Main {

    public static void main(String[] args) {
        // Sub是需要你定义的子类
        Base base = new Sub();

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            base.setX(x);
            base.setY(y);
            System.out.println(base.calculate());
        }
    }

}

abstract class Base {

    private int x;
    private int y;

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int calculate() {
        if (avg() == 0) {
            return 0;
        } else {
            return sum() / avg();
        }
    }

    /**
     * 返回x和y的和
     */
    public abstract int sum();

    /**
     * 返回x和y的平均值
     */
    public abstract int avg();

}

class Sub extends Base {
    public int sum(){
        return super.getX()+super.getY();
    }
    public int avg(){
        return sum() / 2;
    }

}

3. 实现接口(implements)

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Comparator comparator = new ComparatorImpl();

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            System.out.println(comparator.max(x, y));
        }
    }

}

interface Comparator {
    /**
     * 返回两个整数中的最大值
     */
    int max(int x, int y);
}

//write your code here......
class ComparatorImpl implements Comparator{
    public int max(int x,int y){
        return x>y?x:y;
    }
}

八、字符串处理

1. String类

在Java中，String类提供了许多常用的方法来进行字符串操作，以下是一些常用的方法：

• length()。返回字符串的长度。
• charAt(int index)。返回指定索引处的字符。
• isEmpty()。检查字符串是否为空。
• equals(Object obj) 和 equalsIgnoreCase(String anotherString)。比较字符串的内容，后者忽略大小写。
• compareTo(String anotherString)。比较两个字符串的字典顺序。
• contains(CharSequence s)。判断字符串是否包含指定的子字符串或字符序列。
• trim()。去除字符串两端的空格。
• toUpperCase() 和 toLowerCase()。将字符串转换为大写或小写。
• substring(int beginIndex) 和 substring(int beginIndex, int endIndex)。返回从指定位置开始的子字符串。
• replace(CharSequence oldVal, CharSequence newVal)。替换字符串中的指定值。
• split(String regex)。根据正则表达式拆分字符串。
• startsWith(String prefix) 和 endsWith(String suffix)。判断字符串是否以指定的前缀或后缀开始/结束。
• indexOf(String str) 和 lastIndexOf(String str)。返回指定子字符串第一次出现的位置，后者从末尾开始查找。
• line.replaceAll("[^a-zA-Z]", "") 中的 replaceAll() 方法接受两个参数。第一个参数是一个正则表达式，用于指定要替换的字符模式。在这里，[^a-zA-Z] 表示匹配任何不是英文字母的字符。^ 表示取反，a-zA-Z 表示所有英文字母。第二个参数是用于替换匹配到的字符的字符串，这里是空字符串 ""，即将匹配到的非字母字符替换为空字符串。

2. Stringbuffer类

StringBuffer类是Java中用于字符串处理的常用类，它提供了多种方法来操作字符串。以下是StringBuffer类的一些常用方法：

• append(String s)。将指定的字符串追加到此字符序列的末尾。
• delete(int start, int end)。移除此序列的子字符串中的字符，从start位置到end位置（不包括end位置）。
• insert(int offset, String str)。在指定的偏移量offset处插入字符串str。
• replace(int start, int end, String str)。替换此序列中从start到end位置的子字符串为str。
• reverse()。将此字符序列用其反转形式取代。
• charAt(int index)。返回指定索引位置的字符。
• setCharAt(int index, char ch)。替换指定索引位置的字符。
• deleteCharAt(int index).删除指定索引位置的字符。
• toString()。将StringBuffer对象转换成String对象。
• length()。返回序列的长度。

例题：对一个字符串，从右往左，每三个字符插入一个逗号。

import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        StringBuilder newstr = new StringBuilder(str); //用原字符串创建可改变的字符串
        for(int i = str.length() - 3; i >= 0; i -= 3){ //从末尾开始，三个三个遍历
           newstr.insert(i, ','); //插入逗号
        }
        System.out.println(newstr.toString()); //转变成String类输出
    }

3.Character类

|--------------------------------------------|------------------------------------------------------------------------------------|
| void Character(char value) | 构造一个新分配的 Character 对象，用以表示指定的 char 值 |
| char charValue() | 返回此 Character 对象的值，此对象表示基本 char 值 |
| int compareTo(Character anotherCharacter) | 根据数字比较两个 Character 对象 |
| boolean equals(Character anotherCharacter) | 将此对象与指定对象比较，当且仅当参数不是 null，而 是一个与此对象 包含相同 char 值的 Character 对象时， 结果才是 true |
| boolean isDigit(char ch) | 确定指定字符是否为数字，如果通过 Character. getType(ch) 提供的字 符的常规类别类型为 DECIMAL_DIGIT_NUMBER，则字符为数字 |
| boolean isLetter(int codePoint) | 确定指定字符（Unicode 代码点）是否为字母 |
| boolean isLetterOrDigit(int codePoint) | 确定指定字符（Unicode 代码点）是否为字母或数字 |
| boolean isLowerCase(char ch) | 确定指定字符是否为小写字母 |
| boolean isUpperCase(char ch) | 确定指定字符是否为大写字母 |
| char toLowerCase(char ch) | 使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为小写 |
| char toUpperCase(char ch) | 使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为大写 |

九、数字相关

1. 十进制转二进制

1.1 调用API函数

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();

        String n=Integer.toBinaryString(num);
        System.out.print(n);
        

    }
}

1.2 直接运算

public static String decimalToBinary(int decimal) {
    StringBuilder binary = new StringBuilder();
    while(decimal > 0) {
        binary.insert(0, decimal % 2);
        decimal = decimal / 2;
    }
    return binary.toString();
}

2. 生成随机数

2.1 使用Random类

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int seed = scanner.nextInt();
            Random random = new Random(seed);
            //生成[1,6]之间的随机数，nextInt(n)生成随机数的区间为[0,n)
            int n=random.nextInt(6)+1;
            System.out.print(n);
            

        }
    }

}

2.2 Math.random（）

Math.random()返回一个0到1之间的double值

3. Math类

Java Math类提供了许多用于执行数学运算的静态方法。下面是Java Math类的一些常用方法：

• abs()方法：返回一个数的绝对值。
• ceil()方法：返回大于或等于参数的最小double值，等于一个整数。
• floor()方法：返回小于或等于参数的最大double值，等于一个整数。
• max()方法：返回两个参数中的较大值。
• min()方法：返回两个参数中的较小值。
• pow()方法：返回第一个参数的第二个参数次幂。
• sqrt()方法：返回参数的平方根。
• random()方法：返回一个随机数，范围在0.0到1.0之间。
• 9. round()方法：返回参数的四舍五入值，返回类型为long。
• toDegrees()方法：将弧度转换为角度。
• toRadians()方法：将角度转换为弧度。
• sin()方法：返回参数的正弦值。
• cos()方法：返回参数的余弦值。
• tan()方法：返回参数的正切值。
• atan()方法：返回参数的反正切值。
• log()方法：返回参数的自然对数。
• exp()方法：返回e的参数次幂。
• atan2()方法：返回两个参数的反正切值。

十、日期相关

1. Calendar的使用

获取Calendar实例

Calendar cal = Calendar.getInstance(); // 获取当前日期和时间
Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT")); // 获取 GMT 时区的当前日期和时间

获取和设置时间日期

cal.get(Calendar.YEAR); // 获取年份
cal.get(Calendar.MONTH); // 获取月份 (注意：Calendar 的月份从 0 开始计数)
cal.get(Calendar.DAY_OF_MONTH); // 获取日期
cal.get(Calendar.HOUR_OF_DAY); // 获取 24 小时制的小时数
cal.get(Calendar.MINUTE); // 获取分钟数
cal.get(Calendar.SECOND); // 获取秒数
 
// 设置日期和时间
cal.set(Calendar.YEAR, 2020);
cal.set(Calendar.MONTH, Calendar.JANUARY);
cal.set(Calendar.DAY_OF_MONTH, 1);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);

示例：获取某一年某一月的天数

import java.util.Calendar;
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner console = new Scanner(System.in);
        int year = console.nextInt();
 
        //获取Calendar的实例
        Calendar calendar=Calendar.getInstance();
        //循环遍历所有的月份
        for(int month=1;month<=12;month++){
            //设置年、月、日
            calendar.set(year,month,0);
            //输出对应年份各个月的天数
        //getActualMaximum(Calendar.DATE) 方法返回了当前 Calendar 对象表示的月份的最大日期数。
             System.out.println(year+"年"+month+"月:"+calendar.getActualMaximum(Calendar.DATE)+"天");
        }
 
    }
}

2. 日期换算

public class Main {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Scanner in = new Scanner(System.in);
        String str1 = in.nextLine();
        String[] arr = str1.split(" "); //依据空格分开
        if (arr.length != 6) //不足6项，不合理的输入
            System.out.println("您输入的数据不合理");
        else {
            //将字符串组合成日期格式
            String temp = arr[0] + "-" + arr[1] + "-" + arr[2] + " " + arr[3] + ":" + arr[4] + ":" + arr[5];
            Date date = sdf.parse(temp); //将字符串转换成日期
            System.out.println("北京时间为：" + sdf.format(
                                   date.getTime())); //格式化后输出
            System.out.println("纽约时间为：" + sdf.format(date.getTime() -
                               (long) 12 * 60 * 60 * 1000)); //减去12h
        }
    }
}

十一、异常处理

1. 编写异常处理

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int score = scanner.nextInt();
        try{
            if(score >= 0 && score <= 100) //正常分数输出
                System.out.println(score);
            else
                throw new ScoreException("分数不合法"); //抛出异常
        }
        catch(ScoreException str){
            System.out.println(str.getMessage()); //输出异常
        }
    }
}
 
class ScoreException extends Exception{ //继承自异常类的分数异常处理类
    public ScoreException(String message){ //构造函数
        super(message); //输入异常信息
    }
}

十二、Set

1.Set接口常用方法

• add(Object obj)：向Set集合中添加元素，添加成功返回true，否则返回false
• size() ：返回Set集合中的元素个数
• remove(Object obj) ： 删除Set集合中的元素，删除成功返回true，否则返回false
• isEmpty() ：如果Set不包含元素，则返回 true ，否则返回false clear() ： 移除此Set中的所有元素
• iterator() ：返回在此Set中的元素上进行迭代的迭代器
• contains(Object o)：如果Set包含指定的元素，则返回 true，否则返回false

2. 迭代器的使用

Iterator it=set.iterator();
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
        

3. toArray()的使用

• s.toArray() 方法用于将集合s中的元素转换为一个数组。
• 传递一个指定大小的数组作为参数给 toArray() 方法可以确保返回的数组大小足够，如果传递的数组大小不够，则会自动创建一个新的数组来存储元素。
• new String[0] 创建了一个空的 String 数组作为参数传递给 toArray() 方法，目的是让 toArray() 方法自动创建一个合适大小的数组来存储 names 集合中的元素。

s.toArray(new String[0]) 的作用是将s集合中的元素转换为一个 String 数组。

类似的有

List<String> list = new ArrayList<>();
// 添加元素到列表中
list.add("apple");
list.add("banana");
list.add("cherry");
// 将列表转换为数组
String[] array = list.toArray(new String[0]);

十三、Deque

1. ArrayDeque常用方法

1.1 添加元素

• addFirst(E e)在数组前面添加元素
• addLast(E e)在数组后面添加元素
• offerFirst(E e)在数组前面添加元素，并返回是否添加成功 offerLast(E e)在数组后添加元素，并返回是否添加成功

1.2 删除元素

• removeFirst()删除第一个元素，并返回删除元素的值，如果为null，将抛出异常
• removeLast()删除最后一个元素，并返回删除元素的值，如果为null,将抛出异常
• pollFirst()删除第一个元素，并返回删除元素的值，如果为null，将返回null
• pollLast()删除最后一个元素，并返回删除元素的值，如果为null,将返回null

1.3 获取元素

• getFirst()获取第一个元素，如果为null，将抛出异常
• getLast()获取最后一个元素，如果为null，将抛出异常

ArrayDeque当栈和队列用时，对应方法与标准的一样

栈（ArrayDeque是一个双向队列，队列的两端都可以进行增删弹出等操作）

队列（ArrayDeque实现Deque接口，而Deque接口是继承了Queue接口）

十四、Map

1. Map的常用方法

• V put(K key, V value)

向map集合中添加Key为key，Value为value的元素，当添加成功时返回null，否则返回value。

• void putAll(Map extends K,? extends V> m)

向map集合中添加指定集合的所有元素

• void clear()

把map集合中所有的键值删除

• boolean containsKey(Object key)

检出map集合中有没有包含Key为key的元素，如果有则返回true，否则返回false。

• boolean containsValue(Object value)

检出map集合中有没有包含Value为value的元素，如果有则返回true，否则返回false。

• Set<Map.Entry<>> entrySet()

返回map到一个Set集合中，以map集合中的Key=Value的形式返回到set中。

 Set<Map.Entry<Integer, String>> entrys = map.entrySet();
        for (Map.Entry<Integer, String> entry : entrys) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }

• boolean equals(Object o)

判断两个map集合的元素是否相同

• V get(Object key)

根据map集合中元素的Key来获取相应元素的Value

• boolean isEmpty()

检出map集合中是否有元素，如果没有则返回true，如果有元素则返回false

• Set keySet()

返回map集合中所有Key

• V remove(Object key)

删除Key为key值的元素

• int size()

返回map集合中元素个数

• Collection values()

返回map集合中所有的Value到一个Collection集合

2. 遍历map的四种方式

1）map.entrySet()方式

//获取map中的所有键值对，结果为set的集合
Set<Map.Entry<String,String>> entries=map.entrySet();
for(Map.Entry<String,String> entry: entries){
    System.out.println(entry);
}
//或者lamdba表达式
entries.forEach(entry->System.out.println(entry));

2. map.keySet()方式

//获取map中的所有键值，结果为set的集合
Set<String>> keys=map.keySet();
for(String key:keys){
    System.out.println(map.get(key));
}

3. map.values()方法

//直接获取map中的所有value值，组装成一个Collection集合
Collection<String> values=map.values();
for(String value:values){
    System.out.println(value);
}

4. forEach方式

/*语法： 当业务代码只有一句的时, {}和;可以省略
map.forEach((键遍历名称,值遍历名称)->{

    //业务代码
});
*/
map.forEach((key,value))->System.out.println(value));

3. 重写comparTo方法

在类方法里重写compareTo方法 可以实现类数组的sort 必须要求类实现Comparable接口（所有继承collections的都实现了这个接口）

在 sort 方法中会自动调用 compareTo 方法 . compareTo 的参数是 Object , 其实传入的就是

然后比较当前对象和参数对象的大小关系:

• 如果当前对象应排在参数对象之前 , 返回小于 0 的数字 ;
• 如果当前对象应排在参数对象之后 , 返回大于 0 的数字 ;
• 如果当前对象和参数对象不分先后 , 返回 0;

class Customer implements Comparable<Customer>{
    private String name;
    private int consumption;

    public Customer(String name, int consumption) {
        this.name = name;
        this.consumption = consumption;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "name='" + name + '\'' +
                ", consumption=" + consumption +
                '}';
    }
    # 按照消费从大到小排列
    public int compareTo(Customer c1){
        return c1.consumption-consumption;
    }
    

}

十五、排序

1. 复杂度分析

十大排序算法（Java实现）_java十大排序算法-CSDN博客