JAVA八股文基础知识（三）

姐姐们的女猿

已于 2023-07-02 17:08:00 修改

阅读量110

点赞数 1

文章标签： java 开发语言

于 2023-07-02 17:07:07 首次发布

本文链接：https://blog.csdn.net/m0_52873654/article/details/131474873

版权

JAVA基础知识

1.异常

Java程序在执行过程中所发生的异常事件可分为两类：

五.BigInteger类和BigDecimal类

(2).LinkedHashSet：不可重复，有序

1.异常

Java中的异常是指Java程序在运行时可能出现的错误或非正常情况，例如在程序中试图打开一个根本不存在的文件，在程序中除0等。异常是否出现，通常取决于程序的输入，程序中对象的当前状态以及程序所处的运行环境。程序抛出异常之后，会对异常进行处理。异常处理将会改变程序的运行环境，处于安全性考虑，同时避免异常程序影响其他正常程序的运行，操作系统通常将出现异常的程序强行中止，并弹出系统错误提示。

Java程序在执行过程中所发生的异常事件可分为两类：

Error：Java虚拟机无法解决的严重问题，这类错误比较严重，仅靠修改程序本身是不能恢复执行的。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError（栈溢出）和OOM（内存溢出）。一般不编写针对性的代码进行处理。

Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：空指针访问，试图读取不存在的文件，网络连接中断，数组角标越界

运行时异常与编译时异常：

1.编译时异常：

在Exception类中，除了RuntimeException类以外，其他子类都是编译时异常，Java编译器会对编译时异常进行检查，如果出现这类异常就必须对其进行处理，否则程序无法通过编译

处理编译时异常有两种方式，具体如下：

使用try...catch语句对异常进行捕获处理。
使用throws关键字声明抛出异常，由调用者对异常进行处理

2.运行时异常：

RuntimeException类及其子类都是运行时异常。运行时异常是在程序运行时由Java虚拟机自动进行捕获处理的，Java编译器不会对异常进行检查。也就是说，当程序中出现这类异常时，即使没有使用try...catch语句捕获异常或使用throws关键字声明抛出异常，程序也能编译通过，只是程序在运行过程中可能报错。

异常处理及语法：

Java异常处理的五个关键字: try、catch、finally、throw、throws

一.捕获异常try…catch
如果异常出现的话，会立刻终止程序，所以我们得处理异常:

① 该方法不处理而是声明抛出，由该方法的调用者来处理(throws)。

② 在方法中使用try…catch的语句块来处理异常。

try-catch的方式就是捕获异常。

语法格式如下：

try{
    		//可能产生异常的代码
    }catch(/*定义一个异常的变量，用来接收try中抛出的异常对象*/){
    		//异常的处理逻辑，异常对象之后,怎么处理异常对象
    		//一般在工作中。会把异常的信息记录到一个日志中
    }
    catch(/*异常类名变量名*/){
}

编写try...catch语句时，需要注意以下几点：

1.try代码块是必需的

2.catch代码块可以有多个，但捕获父类异常的catch代码块必须位于捕获子类异常的catch代码块后面

3.catch代码块必须位于try代码块之后

二.finally语句

finally:有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转,导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

语法格式如下：

try{
    //代码块
    //可能出现的异常捕获
    }catch(ExceptionType e){
        //代码块
        //异常的处理逻辑
    }finally{

       //代码块    
       //无论是否出现异常，都会执行
}

三.抛出异常throw和声明抛出异常throws

Java 异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要人工创建异常对象并抛出（throw）
throw ExceptionInstance;
throws + 异常类型写在方法的声明处，指明方法执行时可能抛出的异常类型，一旦方法执行时出现异常，就会在异常代码处生成一个异常类的对象，此对象满足 throws 后面的类型时，就会被抛出，异常后的代码不会再执行。
修饰符 返回值类型 方法名(参数1，参数2，...)  throws 异常类1，异常类2，...{
    方法体
}

四.自定义异常类要求
（1）声明一个新的异常类，作为 Exception 类或其他某个已经存在的系统异常类或其他用户异常类的子类。即自定义异常类必须继承Exception类或子类。

（2）定义全局变量 serialVersionUID : 唯一标识一个异常类。

（3）为新的异常类定义属性和方法，或重载父类的属性和方法，使这些属性和方法能够体现该类所对应的错误信息

2.Java API

一.String类及其常用方法

在Java中可以通过两种方式对String类对象进行初始化，具体介绍如下：

第一种方式是使用字符串常量直接初始化一个String对象，语法格式如下：

String 变量名=字符串；

String str1=null;//将字符串str1设置为空

String str2=" ";//将字符串str2设置为空字符串

String str3="abc";//将字符串str3设置为“abc"

每个字符串常量都可以当作一个String类的对象使用，因此字符串常量可以直接调用String类中提供的API，实例代码如下：

int len="hello world".length();//len为11，即字符串包含的字符个数

String类是专门用于处理字符串的类，字符串一旦被创建，其内容就不能被改变。

即String s="hello";

s="helloworld";

s的值发生了变化，但实际上是s的只想发生了变化，字符串“hello"被创建之后，存储在字符串常量池中，它的值不能被改变。

第二种方式是调用String类的构造方法初始化字符串对象，其语法格式如下：

String 变量名=new String(字符串）；

String类的常见构造方法，用代码说明：

public class Example{
    public static void main(String[] args) throws Exception{
        //创建一个空字符串
        String str1=new String();//String() :创建一个空字符串
        //创建一个字符数组
        String str2=new String("abcd");//String(String value):根据指定的value创建字符串
        //创建一个字符数组
        char[] charArray=new char[]{'D','E','F'};
        //String(char[] value):根据指定的字符数组创建字符串
        String str3=new String(charArray);
        //创建一个字节数组
        byte[] arr={97,98,99};
        String str4=new String(arr);//String(byte[] bytes):根据指定的字节数组创建字符串
        System.out.println("a"+str1+"b");
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(str4);
    }
}
//运行结果
ab
abcd
DEF
abc

String类的常用方法：

int length();//获取字符串长度

char charAt(int index);//获取指定位置上某个字符

int indexOf(int ch);//返回的是ch在字符串中第一次出现的位置
int indexOf(int ch, int fromIndex);//从fromIndex指定位置开始，获取ch在字符串中出现的位置
int indexOf(String str);//返回的是str在字符串中第一次出现的位置
int indexOf(String str, int fromIndex);//从fromIndex指定位置开始，获取str在字符串中出现的位置
int lastIndexOf(int ch);//返回的是str在字符串中最后一次出现的位置

boolean contains(str);//该方法只判断是否包含

特殊之处：indexOf(str);//可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在
if(str.indexOf("aa")!=-1)//该方法即可以判断是否包含，也可以获取出现的位置

boolean isEmpty(): //判断字符串是否为空，原理就是判断长度是否为0.切记" "也是char并不为空
boolean startsWith(str);//判断字符串是否是以指定内容开头
boolean endsWith(str);//字符串是否是以指定内容结尾
boolean equals(str);//判断字符串内容是否相同。复写了Object类中的equals方法
boolean equalsIgnoreCase();//判断内容是否相同，并忽略大小写

构造函数：
String(char[])
String(char[],offset,count);//将字符数组中的一部分转成字符串

静态方法：
static String copyValueOf(char[]);
static String copyValueOf(char[] data, int offset, int count)
static String valueOf(char[]):

char[] toCharArray();//将字符串转成字符数组

String(byte[])
String(byte[],offset,count)//将字节数组中的一部分转成字符串。

byte[]  getBytes();//将字符串转成字节数组

//将基本数据类型转成字符串
static String valueOf(int)
static String valueOf(double)
String str = 123 + "";
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

String replace(oldchar,newchar);//返回替换后的字符串

//切割
String[] split(regex);//返回一个string数组

//子串。获取字符串中的一部分
String substring(begin);//包含起点到结尾
String substring(begin,end);//从起点到end(不包括end下标)

//将字符串转成大写或则小写
String toUpperCase();//大写
String toLowerCase();//小写

String trim();//将字符串两端的多个空格去除

//两个字符串进行自然顺序的比较
int compareTo(string);//-1,0,1分别代表靠前，相等，靠后.

二.StringBuffer类

StringBuffer类是对String类的增强，它还是lang包中的，即java.lang.StringBuffer类。
StringBuffer类代表可变的字符串，可以对字符串的内容进行增删。
StringBuffer类的很多方法都与String类相同，只不过StringBuffer是可变长度的。
StringBuffer是一个容器。
StringBuffer是final类，不能被继承。

StringBuffer的常用方法：

查看字符串缓存区容量和长度（字符数）——capacity/length

StringBuffer x1 = new StringBuffer();
System.out.println(x1.length()); //容器中的字符个数,实际值
System.out.println(x1.capacity()); //容器的初始容量,理论值

字符串缓存区——添加（append）

StringBuffer x = new StringBuffer();
x.append("hello ");
x.append("the ");
x.append("world");
System.out.println(x);

字符串缓存区——插入（insert）

StringBuffer x = new StringBuffer("happy");
x.insert(2,"ss"); //在指定位置添加元素
System.out.println(x);

字符串缓存区——替换（replace）

StringBuffer x = new StringBuffer("happy");
x.replace(3,5,"cc");//替换指定位置字符串（左闭右开）
System.out.println(x);

字符串缓存区——反转（reverse）

StringBuffer x = new StringBuffer("happy");
System.out.println(x.reverse()); //反转字符串

字符串缓存区——截取（substring）

StringBuffer x = new StringBuffer("happy");
System.out.println(x.substring(2,6));//截取字符串

字符串缓存区——删除

删除从指定位置开始指定位置结束的内容，并返回删除后的字符缓冲区本身——delete

StringBuffer sb = new StringBuffer("hello");
System.out.println(sb.delete(1,2));

根据索引删除掉索引位置上对应的字符，返回删除后的字符缓冲区本身—deleteCharAt

StringBuffer sb = new StringBuffer("hello");
System.out.println(sb.deleteCharAt(4));

字符串缓存区——清空

StringBuffer x = new StringBuffer("hello");
System.out.println(x.length());
System.out.println(x.capacity());
x.delete(0,x.length()); //清空缓存区
System.out.println(x.length());
System.out.println(x.capacity());

三.System类与Runtime类

System类的常用方法

Runtime类的常用方法

方法声明	功能描述
getRuntime()	用于获取Runtime类的实例
exec(String command)	用于根据指定的路径执行对应的可执行文件
freeMemory()	用于返回Java虚拟机的空闲内存量，以字节为单位
maxMemory()	用于返回Java虚拟机的最大可用内存量，以字节为单位
availableProcessors()	用于返回Java虚拟机的处理器个数
totalMemory()	用于返回Java虚拟机的内存总量，以字节为单位

Runtime()常用方法代码例子如下：

public class Example{
    public static void main(String[] args){
        Runtime rt=Runtime.getRuntime();//创建Runtime对象
        System.out.println("处理器的个数:"+rt.availableProcessors()+"个");
        System.out.println("空闲内存量："+rt.freeMemory()/1024/1024+"MB");
        System.out.println("最大可用内存量："+rt.maxMemory()/1024/1024+"MB");
        System.out.println("内存总量："+rt.totalMemory()/1024/1024+"MB");       
    }
}

四.Math类和Random类

Math类的常用方法

public class Example{
    public static void main(String[] args){
        System.out.println("计算-10的绝对值："+Math.abs(-10));
        System.out.println("求大于5.6的最小整数："+Math.ceil(5.6));
        System.out.println("求小于-4.2的最大整数："+Math.floor(-4.2));
        System.out.println("对-4.6进行四舍五入"+Math.round(-4.6));
        System.out.println("求2.1和-2.1中的较大值："+Math.max(2.1,-2.1));
        System.out.println("求2.1和-2.1中的较小值："+Math.min(2.1,-2.1));
        System.out.println("生成一个大于或等于0.0且小于1.0的随机数："+Math.random());
        System.out.println("计算1.57的正弦值："+Math.sin(1.57));
        System.out.println("计算4的平方根："+Math.sqrt(4));
        System.out.println("计算2的3次方的值："+Math.pow(2,3));
    }
}

Random类的常用方法

//1. 导包
import java.util.Random;//java.util.Random ：该类需要 import导入使后使用。
public class Demo01_Random {
    public static void main(String[] args) {
        //2. 创建随机数生成器对象
        Random r = new Random();
        for(int i = 0; i < 3; i++){
            //3. 随机生成一个数据
            int number = r.nextInt(10);//生成int类型的随机数
            //4. 输出数据
            System.out.println("number:"+ number);
        }
       System.out.println(r.nextBoolean());//生成Boolean类型的随机数
       System.out.println("生成boolean类型的随机数：" +r.nextBoolean());
       System.out.println("生成[0,1.0)区间的double类型的随机数：" +r.nextDouble());
       System.out.println("生成float类型的随机数：" +r.nextFloat());
       System.out.println("生成int类型的随机数：" +r.nextInt());
       System.out.println("生成0到10之间int类型的随机数：" +r.nextInt(10));
       System.out.println("生成long类型的随机数：" +r.nextLong());
       System.out.println("生成[0,5.0)区间的小数：" +r.nextDouble() * 5);
    }
}

五.BigInteger类和BigDecimal类

BigInteger类：作用是实现高精度的运算，大整数

import java.math.BigInteger;//导包

public class Test4 {
   public static void main(String[] args) {
   
 //   long b1 = 12345678999;  不符合长度范围
   
    BigInteger b1 = new BigInteger("12345678999");//String类型
    BigInteger b2 = new BigInteger("12345678111");

    //1.加法：
    BigInteger b3 = b1.add(b2);
    double c3 = b3.doubleValue();//
    System.out.println(c3);

    //2.减法：
    BigInteger b4 = b1.subtract(b2);
    double c4 = b4.doubleValue();
    System.out.println(c4);

    //3.乘法：
    BigInteger b5 = b1.multiply(b2);
    double c5 = b5.doubleValue();
    System.out.println(c5);

    //4.除法：
    BigInteger b6 = b1.divide(b2);
    double c6 = b6.doubleValue();
    System.out.println(c6);
}
}

BigDecimal类：表示任意精度的小数

BigDecimal(String val)：构造方法，将String类型转换成BigDecimal类型数据。
BigDecimal(double val)：构造方法，将double类型转换成BigDecimal类型数据。
BigDecimal(int val)：构造方法，将int类型转换成BigDecimal类型数据。
BigDecimal add(BigDecimal value)：加法，求两个BigDecimal类型数据的和。

BigDecimal subtract(BigDecimal value)：减法，求两个BigDecimal类型数据的差。

BigDecimal multiply(BigDecimal value)：乘法，求两个BigDecimal类型数据的积。

BigDecimal divide(BigDecimal divisor)：除法，求两个BigDecimal类型数据的商。

BigDecimal remainder(BigDecimal divisor)：求余数，求BigDecimal类型数据除以divisor的余数。

BigDecimal max(BigDecimal value)：最大数，求两个BigDecimal类型数据的最大值。

BigDecimal min(BigDecimal value)：最小数，求两个BigDecimal类型数据的最小值。

BigDecimal abs()：绝对值，求BigDecimal类型数据的绝对值。

BigDecimal negate()：相反数，求BigDecimal类型数据的相反数。

3.集合

集合都位于java.util包中，使用集合时必须导入java.util包

一.Collection接口

Collection接口的常用方法：

add:添加单个元素
remove:删除指定元素
contains:查找元素是否存在
size:获取元素个数
isEmpty:判断是否为空
clear:清空
addAll:添加多个元素
containsAll:查找多个元素是否都存在
removeAll:删除多个元素

二.List接口

List接口继承自Collection接口，List接口实例中允许存储重复的元素，所有的元素以线性方式存储，且元素是有序的。

List接口的常用方法代码如下：

//ArrayList是List接口的一个实现类，它是程序中最常见的一种集合
//内部的数据存储结构是数组形式。
//由于ArrayList的底层是使用一个数组村粗元素，在增加或删除指定位置的元素时，会创建新的数组，效率比较低
//因此ArrayList集合不适合做大量的增删操作，而适合元素的查找。
import java.util.ArrayList;
import java.util.List;
public class ListMethod {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("张三丰");
        list.add("贾宝玉");
        // void add(int index, Object ele):在 index 位置插入 ele 元素
        // 在index = 1 的位置插入一个对象
        list.add(1,"秋刀鱼");
        System.out.println("list=" + list);
        // boolean addAll(int index,Collection eles):从index位置开始将eles中的所有元素添加进来
        List list2 = new ArrayList();
        list2.add("jack");
        list2.add("tom");
        list.addAll(1,list2);
        System.out.println("list=" + list);
        // Object get(int index):获取指定 index 位置的元素
        System.out.println(list.get(3)); //秋刀鱼
        // int indexOf(Object obj):返回 obj 在集合中首次出现的位置
        System.out.println(list.indexOf("tom")); //2
        // int lastIndexOf(Object obj):返回 obj 在当前集合中末次出现的位置
        list.add("秋刀鱼");
        System.out.println("list=" + list);
        System.out.println(list.lastIndexOf("秋刀鱼")); //5
        // Object remove(int index):移除指定 index 位置的元素，并返回此元素
        list.remove(0);
        System.out.println("list=" + list);
        // Object set(int index, Object ele):设置指定 index 位置的元素为 ele，相当于是替换
        list.set(1,"玛丽");
        System.out.println("list=" + list);
        // List subList(int fromIndex, int toIndex):返回从 fromIndex 到 toIndex 位置的子集合
        // 注意返回的子集合, 包头不包尾！
        List returnList = list.subList(0,2); // [0,2)
        System.out.println("returnList=" + returnList); // [java,玛丽]
    }
}

import java.util.*;
public class ListExercise02 {
    public static void main(String[] args) {
        
        //List list = new ArrayList();
//LinkedList内部包含有两个Node类型的first和last属性的双向循坏链表结构
//特点：增删快，查询慢
        List list = new LinkedList();
        //List list = new Vector();
        list.add(new Book("红楼梦","曹雪芹",100));
        list.add(new Book("西游记","吴承恩",10));
        list.add(new Book("水浒传","施耐庵",9));
        list.add(new Book("三国","罗贯中",80));
        //list.add(new Book("西游记","吴承恩",10));

        //遍历

        for (Object o : list) {
            System.out.println(o);
        }

        //冒泡排序
        sort(list);

        System.out.println("======排序后=======");

        for (Object o : list) {
            System.out.println(o);
        }

    }
    
    //静态方法
    public static void sort(List list) {

        int listSize = list.size();
        for (int i = 0; i < listSize - 1; i++) {
            for(int j = 0; j < listSize - 1 - i;j++){
                //取出对象Book
                Book book1 = (Book)list.get(j);
                Book book2 = (Book)list.get(j+1);
                if(book1.getPrice()>book2.getPrice()){ //交换
                    list.set(j,book2);
                    list.set(j+1,book1);
                }

            }
        }
    }
    
}

三.集合遍历

Iterator接口主要用于迭代访问(遍历）集合中的元素，通常情况下Iterator对象也被称为迭代器。

import java.util.*;
public class Example{
    public static void main(String[] args){
        ArrayList list=new ArrayList();//创建集合
        list.add("张三");
        list.add("李四");
        list.add("王五");
        Iterator it=list.iterator();//获得Iterator对象
        while(it.hasNext()){//判断集合是否有下一个元素
              Object obj=it.next();//获取集合中的元素
              if("张三".equals(obj)){//判断集合中的元素是否为“张三”
                    it.remove(obj)://删除集合中找到的元素
              }
        }
    }
}
Iterator对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素。
在调用Iterator的next()方法之前，Iterator的指针位于第一个元素之前，不指向任何元素；
第一次调用Iterator的next()方法时，Iterator的指针会向后移动一位，指向第一个元素并将该元素返回；
第二次调用Iterator的next()方法时，Iterator的指针会向后移动一位，指向第二个元素并将该元素返回；
以此类推，直到hasNext()方法返回false，表示已经遍历完集合中所有的元素，终止对元素的遍历。

foreach循环

语法格式如下：

for(容器中元素类型临时变量：容器变量）{

执行语句；

}

四.Set接口

(1).HashSet

HashSet是Set接口的一个实现类，它存储的元素是不可重复的，无序的。当向HashSet中添加一个元素时，首先会调用hashCode()方法确定元素的存储位置，然后再调用equals()方法确保该位置没有重复元素。

import java.util.*;
class Student{
    private  String id;
    private  String name;
    public  Student(String id,String name){
        this.id=id;
        this.name=name;
    }
    //重写toString()方法
    @Override
    public String toString() {
        return id+":"+name;
    }
    //重写hashCode()方法
    @Override
    public int hashCode() {
        return id.hashCode();//返回id属性的哈希值
    }
    //重写equals()方法

    @Override
    public boolean equals(Object obj) {
        if(this==obj){      //判断是否同一个对象
            return  true;   //如果是，直接返回false
        }
        if(!(obj instanceof Student)){//判断对象是否为Student类型
            return false;
        }
        Student stu=(Student)obj;//将对象转换为Student类型
        boolean b=this.id.equals(stu.id);//判断id值是否相同
        return b;//返回判断结果
    }
}
public class Main{
    public  static  void  main(String[] args){
        HashSet hs=new HashSet();//创建集合对象
        Student stu1=new Student("1","张三");//创建Student对象
        Student stu2=new Student("2","李四");
        Student stu3=new Student("2","李四");
        hs.add(stu1);//向集合中存入对象
        hs.add(stu2);
        hs.add(stu3);
        System.out.println(hs);//打印集合中的元素
    }


}

(2).LinkedHashSet：不可重复，有序

import java.util.*;
public class Example{
    public static void main(String[] args){
        LinkedHashSet  set=new LinkedHashSet();//创建集合
        Set.add("张三");
        Set.add("李四");
        Set.add("王五");
        Iterator it=set.iterator();//获得Iterator对象
        while(it.hasNext()){//判断集合是否有下一个元素
              Object obj=it.next();//获取集合中的元素
              System.out.printlm(obj);
        }
    }
}

(3).TreeSet

TreeSet特点：有序，无重复元素，采用二叉树存储元素

TreeSet特有方法：

Object first() //返回TreeSet集合的首个元素
Object last() //返回TreeSet集合的最后一个元素
Object lower() //返回TreeSet集合中小于给定元素的最大元素，如果没有返回null
Object floor() //返回TreeSet集合小于或等于给定元素的最大元素，如果没有返回null
Object higher() //返回TreeSet集合中大于给定元素的最小元素，如果没有返回null
Object ceiling() //返回TreeSet集合中大于或等于给定元素的最小元素，如果没有返回null
Object pollFirst() //移除并返回集合的第一个元素
Object pollLast() //移除并返回集合的最后一个元素

package com.sgl;

import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {

        //创建TreeSet集合
        TreeSet<Object> treeSet = new TreeSet<>();
        //1.向集合中添加元素
        treeSet.add(3);
        treeSet.add(9);
        treeSet.add(1);
        treeSet.add(21);
        System.out.println("创建的TreeSet集合为:"+treeSet);
        //2.获取首尾元素
        System.out.println("TreeSet集合首元素为:"+treeSet.first());
        System.out.println("TreeSet集合尾部元素为:"+treeSet.last());
        //3.比较并获取元素
        System.out.println("集合中小于或等于9的最大一个元素为:"+treeSet.floor(9));
        System.out.println("集合中大于10的最最小一个元素为:"+treeSet.higher(10));
        System.out.println("集合中小于100的最最小一个元素为:"+treeSet.higher(100));
        //4.删除元素
        Object first = treeSet.pollFirst();
        System.out.println("删除第一个元素是:"+first);
        System.out.println("删除第一个元素后TreeSet集合变为:"+treeSet);

    }
}

(4).自然排序

自然排序要求向TreeSet集合中存储的元素所在类必须实现Comparable接口，实现Comparable的类必须实现 compareTo(Object obj) 方法，两个对象即通过compareTo(Object obj)方法的返回值来比较大小。如果当前对象this大于形参对象obj，则返回正整数，如果当前对象this小于形参对象obj，则返回负整数，如果当前对象this等于形参对象obj，则返回零。

import java.util.*;
class Student implements Comparable{
    private  String name;
    private  int age;
    public  Student(String name,int age){
        this.age=age;
        this.name=name;
    }
    //重写toString()方法
    @Override
    public String toString() {
        return name+":"+age;
    }
    //重写Comparable接口的compareTo()接口
    @Override
    public int compareTo(Object obj) {
        Student stu = (Student) obj;
        //定义比较方式，先比较age,再比较name
        if (this.age - stu.age > 0) {
            return 1;
        }
        if (this.age - stu.age == 0) {
            return this.name.compareTo(stu.name);
        }
        return -1;
    }
}
public class Main{
    public  static  void  main(String[] args){
        TreeSet hs=new TreeSet();//创建集合对象
        Student stu1=new Student("Lucy",18);//创建Student对象
        Student stu2=new Student("Tom",20);
        Student stu3=new Student("Bob",20);
        hs.add(stu1);//向集合中存入对象
        hs.add(stu2);
        hs.add(stu3);
        System.out.println(hs);//打印集合中的元素
    }

}

(5).自定义排序

自定义排序要求自定义一个比较器，该比较器必须实现Comparator接口，并重写compare（）方法，必须将该比较器作为参数传入集合的有参构造。

可以将 Comparator传递给 sort方法（如 Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。

public static void main(String[] args) {

		TestA testA1 = new TestA("老张", 3);
		TestA testA2 = new TestA("老李", 1);
		TestA testA3 = new TestA("老王", 2);
		List<TestA> list  = new ArrayList<>();
		list.add(testA1);
		list.add(testA2);
		list.add(testA3);
		System.out.println("排序前--:"+list.toString());
		Collections.sort(list, new Comparator<TestA>() {
            @Override
            public int compare(TestA o1, TestA o2) {
                //升序
                return o1.getAge().compareTo(o2.getAge());
            }
        });
		System.out.println("升序排序后--:"+list.toString());
		
		Collections.sort(list, new Comparator<TestA>() {
            @Override
            public int compare(TestA o1, TestA o2) {
                //降序
                return o2.getAge().compareTo(o1.getAge());
            }
        });
		System.out.println("降序排序后--:"+list.toString());
	}

五.Map接口

（1)Map集合的特点：

Map是一个双列集合，一个元素包含两个值（一个key，一个value）
Map集合中的元素，key和value的数据类型可以相同，也可以不同
Map中的元素，key不允许重复，value可以重复，访问Map集合中的元素时，只要指定了键，就能找到对应的值
Map里的key和value是一一对应的。

(2)Map接口的常用方法：

//添加功能

put(K key,V value):添加元素。
如果键是第一次存储，就直接存储元素，返回null
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值

//删除功能

void clear():移除所有的键值对元素

remove(Object key)：根据键删除键值对元素，并把值返回

//判断功能

boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空

//获取功能

Set<Map.Entry<K,V>> entrySet():
get(Object key):根据键获取值
Set<K> keySet():获取集合中所有键的集合
Collection<V> values():获取集合中所有值的集合

//长度功能

int size()：返回集合中的键值对的个数

(3)HashMap

HashMap集合底层是哈希表结构组成的。HashMap是一个最常用的Map集合，它根据键的HashCode值存储数据，根据键获取值，具有很快的访问速度，遍历时，获取的数据的顺序是随机的。
HashMap只允许一条记录的键为null，而允许多条记录的值为null
HashMap不支持线程同步（任意一个时刻有多个线程同时写HashMap），可能会导致数据的不一致。如果需要同步，可以用Collections的synchronizedMap方法使HashMap具有同步的能力，或者使用ConcurrentHashMap

(4)LinkedHashMap

LinkedHashMap保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的。也可以在构造时带参数，按照应用次数排序。
LinkedHashMap在遍历的时候会比HashMap慢，不过有种情况例外：当HashMap容量很大，实际数据较少时，遍历起来可能会比LinkedHashMap慢。因为LinkedHashMap的遍历速度只和实际数据有关，和容量无关，而HashMap的遍历速度和他的容量有关。
键(key)和值(value)均允许为null，线程不同步的。

(5)TreeMap

TreeMap实现SortMap接口，能够把它保存的记录根据键排序。
默认是按照键(key)的升序排序，也可以指定排序的比较器，当用iterator遍历TreeMap时，得到的记录是排过序的。
TreeMap不允许键(key)的值为null，线程不同步的。

TreeMap对集合中的键进行排序的方法
方式一：元素自身具备比较性
和TreeSet一样原理，需要让存储在键位置的对象实现Comparable接口，重写compareTo方法，也就是让元素自身具备比较性，这种方式叫做元素的自然排序也叫做默认排序。
方式二：容器具备比较性
当元素自身不具备比较性，或者自身具备的比较性不是所需要的。那么此时可以让容器自身具备。需要定义一个类实现接口Comparator，重　　写compare方法，并将该接口的子类实例对象作为参数传递给TreeMap集合的构造方法。

姐姐们的女猿

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
JAVA八股文基础知识（三）

自定义排序要求自定义一个比较器，该比较器必须实现Comparator接口，并重写compare（）方法，必须将该比较器作为参数传入集合的有参构造。可以将Comparator传递给sort方法（如或），从而允许在排序顺序上实现精确控制。TestA testA1 = new TestA("老张", 3);TestA testA2 = new TestA("老李", 1);TestA testA3 = new TestA("老王", 2);
复制链接

扫一扫