Java常用类、集合总结

1、Object类中的常用方法有哪些，功能是什么？
    int  hashCode()返回该对象的哈希码值。
    getClass ()返回一个对象的运行时类。
    equals（object obj）判断两个对象是否相等。
    finalize() 运行垃圾回收器。
    clone()创建并返回此对象的一个副本。
    toString()返回该对象的字符串表示形式。

2、==与equals的区别？
    ==: 既可以比较基本数据类型也可以比较引用数据类型
    基本类型: 比较的是值是否相同
    引用类型: 比较的是地址值是否相同
    equals: 只能比较引用数据类型
    默认情况下,比较的是地址值是否相同。
    重写: 比较两个内容是否相等。
3、String类的常用构造方法都有哪些，并写出参数类型？
       1.String();创建空字符串对象
       2.String(byte[]bytes);将字节数组解码为字符串
       3.String(byte[]bytes,int offset,int length);将字节数组的一部分解码为字符串
       4.String(char[]value);将字符数组解码为字符串
       5.String(char[]value,int offset,int count);将字符数组的一部分解码为字符串
4、String类的常用方法是什么？写8个，并写上作用？
    基本操作：
        length():获取字符串的长度
        indexOf(String str):获取小字符串在大字符串中第一次出现的索引位置
        lastIndexOf(String str):获取小字符串在大字符串中最后一次出现的索引位置
        charAt(int index):获取指定索引处的字符
    转换操作：
        getBytes():将字符串转为字节数组
        toCharArray():将字符串转为字符数组
        toLowerCase():将字符串所有字符转为小写
        toUpperCase():将字符串所有字符转为大写
        valueOf(基本数据类型):将基本数据类型转为字符串(静态方法)
    替换和去除：
        replace(String oldStr,String newStr):将字符串中旧的字符串替换为新的字符串，返回替换后的结果。
        trim():去除字符串中首尾空格，返回去除空格后的字符串结果。
    判断：
        equals(Object obj):判断两个字符串的内容是否相同。
        startsWith(String str):判断字符串是否以指定的字符串开头。
        endsWith(String str):判断字符串是否以指定的字符串结尾。
        contains(String str):判断字符串是否包含指定的字符串。
        isEmpty():判断字符串是否为空。
    
    compareTo():按照字典比较两个字符串的大小

5、String s = new String(“abc”)与String s = “abc”的区别？
    第一个：创建一个或两个对象，如果常量池中有abc对象，就创建只再堆中new了一个对象;如果常量池中没有，就先在堆中创建一个对象，
    再常量池中创建abc对象。
    第二个：创建一个对象或者零个对象，如果常量池中存在abc对象，那么就不创建新得对象;如果常量池中没有abc对象，那么就创建新得abc对象。

6、String类中如何将字符串和byte[]、char[]数组相互转换？
    字符串转为字符数组：调用toCharArray()方法。
    字符数组转为字符串：使用字符串得构造方法String(char[] chars);
    
    字符串转为字节数组：调用getBytes()方法。
    字节数组转为字符串：使用字符串得构造方法String(byte[] bytes);

7、String、StringBuffer和StringBuilder的区别？
    String是一个不可变的字符串。
    StringBuffer 是一个线程安全的可变的字符序列。
    StringBuilder是一个线程不安全的可变的字符序列。
8、简述StringBuffer和String之间的转换？    
    //String--->StringBuffer
    StringBuffer sb = new StringBuffer(“java”);
    
    //StringBuffer--->String
    1.通过构造方法：String s =new String(sb);
    2.通过toString方法；StringBuffer类也重写了toString方法；

9、冒泡排序手写排序代码？
        // 定义一个静态数组
        int[] arr = { 28, 7, 88, 74, 56, 55 };
        // 冒泡
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
10、列举基本数据类型的包装类？    
    Byte,Short,Integer,Long,Float,Double,Boolean,Character
11、简述Arrays中的常用方法，并写出这些方法的意义？    
    copyOf及copyOfRange方法 ：数组拷贝
    sort方法 ：对数组中元素排序
    toString方法 ：将数组转为字符串形式

12、简述基本数据类型int与String互相转化的？
    String转int类型
        int y = Integer.parseInt(“123”);//Integer中的静态方法
    int转String类型
        String s2 = String.valueOf(10);//String中的静态方法

13、简述什么是自动装箱，自动拆箱？
    自动装箱：基本类型自动转为包装类（int >> Integer）
    自动拆箱：包装类自动转为基本类型（Integer >> int）    

14、简述Integer类中的常用方法，并写出这些方法的意义？
    Integer：
        int parseInt(String s)：将字符串转为int类型。
        toString(int i) ：将int类型转为字符串
        Integer valueOf(int i)：将int类型转为Integer对象
        Integer valueOf(String s) ：将字符串转为Integer类型。
        String toBinaryString(int i) ：将十进制转为二进制的字符串形式。
        String toHexString(int i) ：将十进制转为十六进制的字符串形式。
        String toOctalString(int i) ：将十进制转为八进制的字符串形式

15、简述Character类中的常用方法，并写出这些方法的意义？
    Character包装类基本用法：
    Character character = new Character('A');将char转为Character包装类
    char charValue = character.charValue();从Character包装类中获取char字符
    静态方法：
    Character.isUpperCase(char ch);判断字符是否为大写
    Character.toLowerCase(char ch);.将字符转为小写,返回转换后的小写字符
    Character.isLowerCase(char ch);判断字符是否为小写
    Character.isDigit(char ch);判断字符是否为数字
    Character.toUpperCase(char ch);.将字符ch转为大写字符，返回转换后的结果

16、简述Math中的常用方法，并说明意义    
    int chInt = (int)(Math.random()*(123-97)+97);随机一个[97,123)对应的小写字符
    
    int abs(int a);绝对值
    int max(int a,int b);最大值
    double round(float a);四舍五入
    double pow(double a,double b)a的b次幂
    double ceil(double a);向上取整
    double floor(double a);向下取整
    double sqrt(double a);整平方根
    random()[0.0,1.0);随机产生数   (Math.random()*(m-n)+n);
17、简述Random类的使用方式，并举例说明方法的作用
    创建随机指定种子对象Random random2 = new Random();
    随机播种种子方法random.nextInt(m-n)+n;

18、简述System类的常用方法，并说明意义    
    System.gc();通知JVM运行垃圾回收期
    System.exit(0);后面代码不再运行了，0代表正常结束。
    System.currentTimeMillis();

19、简述Date类的常用方法，并说明意义    
    Date()：通过无参构造方法创建对象，表示的是系统当前时间。
    Date(long time):通过指定的long型值，构造对应的Date对象。

    public long getTime()
    这个方法获取到的就是从1970年1月1日0时开始计算的你电脑系统的时间的毫秒值。
    public void setTime(long time)
    这个方法是用来设定时间的毫秒值，比如我们使用了无参构造方法，但是想得到某一值的具体日期，则可以使用这个方法设定。

20、简述SimpleDateFormate的用法，举例说明    

    Date--->String
    Date date = new Date();
    String pattern = "y年M月d日H时m分s秒S毫秒 E";
    SimpleDateFormat sdf = new SimpleDateFormat(pattern);
    String format = simpleDateFormat.format(date);
    
    String--->Date
    String strTime = "2018年8月29日 15点37分46秒481毫秒 星期三";
    SimpleDateFormat sdf = new SimpleDateFormat(pattern);
    //sdf.parse(strTime)：sdf将strTime解析为Date对象
    Date parse = sdf.parse(strTime);
    System.out.println(strTime);
    System.out.println(parse);
        

21、正则表达式的作用是什么？    
    对字符串得匹配、查找、替换、判断。
22、简述正则表达式中的字符都有哪些，代表什么？
    1、x字符x。举例：a表示字符a
    2、\\反斜线字符
    3、\n 新行 （换行）符
    4、\r 回车符

23、简述正则表达式中的字符类都有哪些，代表什么？
    1、[abc]a、b、或c(简单类)
    2、[^abc]任何字符，除了a,b或c(否定)
    3、[a-zA-Z]a到z或A到Z，两头的字母包括在内(范围)
    4、[0-9]0到9的字符都包括

24、简述正则表达式中的预定义字符类都有哪些，意义是什么？
    预定义字符：
    1、 . 任何字符。我就是.字符本身，怎样表示呢？\.
    2、 \d 数字：[0-9]
    3、 \w 单词字符[a-zA-Z_0-9]
          在正则表达式里面组成单词的东西必须有这些东西组成

25、述正则表达式中的边界匹配类都有哪些，意义是什么？
    ^ 行的开头
    $ 行的结尾
    \b  单词边界

26、简述正则表达式中的数量词都有什么，意义是什么？    
    x？x   是一次或零次
    x*x    是零次或多次
    x+x    是一次或多次
    {n}    是恰好n次
    {n，}  是至少n次
    {n，m} 是至少n次 但不超过m次

27、正则表达式中常用的String类中的三个方法？
    matches(正则)  是判断功能
    split(正则)    是分割功能
    replaceAll(正则，替换为新的内容) 是替换功能

28、集合与数组区别
    ①集合长度是可变的，数组长度数不可变的；
    ②数组用来存放基本数据类型和引用数据类型；集合用来存放对象；
    ③同一个数组只能存储一种引用类型数据，同一个集合可以储存不同引用数据类型（不建议，遍历不方便）
29、Collection类
    Collection集合框架的根接口
        子接口List：有序，可重复
            三个实现类：ArrayList、Vector、LinkedList
        子接口Set：无序，不可重复
            三个实现类：HashSet、LinkedHashSet、TreeSet
30.创建Collection对象
    Collection col = new ArrayList();
    成员方法：
    coll.add(E e);                作用：向集合中添加一个元素；
    coll.remove(Object o);        作用：移除集合中指定的元素；
    coll.clear();                作用：清空集合；
    coll.contains(Object o);    作用：判断集合中是否包含该元素；
    coll.isEmpty();                作用：判断集合是否为空；
    coll.size();                作用：集合的长度；
    coll.addAll();                作用：将该集合中的元素添加到另一个集合中；
    coll.removeAll();            作用：移除另一个集合中包含该集合的元素；
    Object[]toArray;            作用：把集合转为数组；
    Iterator接口类（迭代器，集合的专用遍历方式）
    成员方法：
    boolean hashNext();            作用：如果仍有元素可以迭代，则返回true；
    Objcet next();                作用：获取元素，并移动到下一个位置；
    NoSuchElementException;        作用：没有这样的元素，因为你已经找到最后了；
    使用方法：
    Iterator a=coll.iterator();
    while(a.hashNext()){
        Objcet next=a.next();
        System.out.println((String)next);
    }
31、List接口的特殊方法；
    add(int index,E element)    作用：添加指定元素；
    remove();                    作用：移除指定元素；
    get();                        作用：获取指定位置的元素；
    set();                        作用：修改指定位置的元素；
    listIterator();                作用：获取List专用迭代器；
32、数据结构类型：
    1、栈：先进后出；
    2、队列：先进先出
    3、数组：具有索引，查询快，长度不可变，增删慢；
    4、链表：链表保证有序，能在指定位置进行删除和插入但每次查询都要从头开始；总结：增删快，查询慢；
33、ArrayList类
    特点：
    底层数据结构是数组，查询快，增删慢，线程不安全，效率高，有序，可重复；
    构造方法：
    ArrayList();                            作用：无参构造，构造一个初始容量为10的空列表；
    ArrayList(Collection<? extends E> c);    作用：构造一个包含指定collection的元素的列表；
    遍历方式：
    ArrayList arr=new ArrayList();
    arr.add("张三");
    ①：//普通for遍历；
    for(int i=0;i<arr.size();i++){
        System.out.println(arr.get(i));
    }
    ②：//增强for循环：
    for(String strng:arr){
        System.out.println(string);
    }
    ③：//List迭代器遍历：
    ListIterator listIterator=arr.listIterator();
    while(listIterator.hasNext()){
        Objcet next=listIterator.next();
        System.out.println(next);
    }

34、List接口：ArrayList、Vector、LinkedList;
    1.ArrayList:
        1.1特点
        底层数据结构是数组，查询快，增删慢
        线程不安全，效率高;
        1.2构造方法
            无参，初始容量为10
    2.Vector：
        2.1特点
        底层数据结构是数组，查询快，增删慢
        线程安全，效率低
        2.2构造方法
        无参，初始容量10
        2.3特有的方法(了解)
        添加：addElement(Object obj):添加元素到集合中
        获取Enumeration对象：elements():获取Enumeration对象，用于遍历集合中元素
        Enumeration方法：
            hasMoreElment():判断集合中是否还有元素
            nextElment():获取遍历到的元素 
        
    3.LinkedList：
        3.1特点
        底层数据结构是链表，查询慢，增删快
        线程不安全，效率高
        3.2构造方法
        无参
        3.3特有方法
        addFirst(Object o):添加一个元素到首部
        addLast(Object o):添加一个元素到尾部
        getFirst(Object o):获取集合中首部的元素
        getLast(Object o):获取集合中尾部的元素
        removeFirst():移除集合中首部的元素
        removeLast():移除集合中尾部的元素
    
35、泛型：大写字母表示
    泛型的好处
    A:把运行时期的问题提前到了编译期间
    B:避免了强制类型转换
    C:优化了程序设计，解决了黄色警告线问题，让程序更安全

36、增强for循环：简化数组和集合的遍历(本质是迭代器，可以替代迭代器)
    格式：
        for(元素的数据类型  变量名 : 数组或集合对象){
            变量名代表的就是遍历到的元素;
        }
    好处：简单，易于书写。

37、Set集合：无序不可重复
    1.HashSet：
        底层数据结构是哈希表。
        如何保证数据唯一：
            1.先比较hashCode()方法的返回值是否在集合中存在。
            2.如果返回结果是存在的，再去比较equals()，如果返回值为true，代表数据唯一，添加不到集合中。
    2.TreeSet：
        可以对元素进行排序及去重。
        如何实现排序：
        1.自然排序：
            让自定义的类实现Comparable接口，重写compareTo方法实现比较规则，这种方式就是自然排序。
        2.比较器排序：
            不需要让自定义的类去实现Comparable接口，但是需要在创建TreeSet集合的时候使用一个参数的
            构造方法传入一个Comparator接口对象。
        
        如何实现去重呢：
            无论是那种排序规则，只要比较后的结果为0就代表元素重复，添加不到集合中去。
            
        如果抛出//ClassCastException类型转换异常
            就说明TreeSet集合添加的元素，没有使用自然排序，也没有使用比714714177较器排序。
    3.LinkedHashSet：
        有序不可重复;
        有序：底层数据结构是链表来保证元素有序。
        不可重复：底层数据结构是哈希表保证数据唯一。