Java常用方法

一、输入

直接读

Scanner scan = new Scanner(System.in);

scan.next();//String
scan.nextLine();//String
scan.nextBoolean();//Boolean
scan.nextByte();//Byte
scan.nextShort();//Shor
scan.nextInt();//Int
scan.nextLong();//Long
scan.nextDouble();//Double
scan.nextFloat();//Float
scan.nextBigInteger();//BigInteger
scan.nextBigDecimal();//BigDecimal

二、String类

和长度有关的方法

//返回类型      方法名               作用
int        length()        得到一个字符串的字符个数（一个中文是一个字符，一个英文是一个字
//符，一个转义字符是一个字符）

和数组有关的方法 

//返回类型        方法名             作用
byte[]        getBytes()       将一个字符串转换成字节数组
char[]        toCharArray()    将一个字符串转换成字符数组
String[]      split(String)    将一个字符串按照指定内容劈开

和判断有关的方法

//返回类型        方法名                         作用
boolean       equals(String)                判断两个字符串的内容是否一模一样
boolean       equalsIgnoreCase(String)      忽略大小写的比较两个字符串的内容是否一模一样
boolean       contains(String)              判断一个字符串里面是否包含指定的内容
boolean       startsWith(String)            判断一个字符串是否以指定的内容开头
boolean       endsWith(String)              判断一个字符串是否以指定的内容结尾

和改变内容有关的方法

和改变内容有关的方法，都不会直接操作原本的字符串
而是将符合条件的字符串返回给我们，所以注意接收

//返回类型        方法名                         作用
String        toUpperCase()                 将一个字符串全部转换成大写
String        toLowerCase()                 将一个字符串全部转换成小写
String        replace(String,String)        将某个内容全部替换成指定内容
String        replaceAll(String,String)     将某个内容全部替换成指定内容，支持正则
String        repalceFirst(String,String)   将第一次出现的某个内容替换成指定的内容
String        substring(int)                从指定下标开始一直截取到字符串的最后
String        substring(int,int)            从下标x截取到下标y-1对应的元素
String        trim()                        去除一个字符串的前后空格

和位置有关的方法

//返回类型        方法名                     作用
char          charAt(int)               得到指定下标位置对应的字符
int           indexOf(String)           得到指定内容第一次出现的下标
int           lastIndexOf(String)       得到指定内容最后一次出现的下标

1、Math类（数学、计算相关）

Java中已有的E、和PI的值

public static final double E = 2.7182818284590452354;
public static final double PI = 3.14159265358979323846;
 
static Object abs(Object o) //返回值为 Object 的绝对值
static Object min(Object a, Object b) //返回两个 Object的较小值
static Object max(Object a, Object b) //返回两个 Object的较大值
static double ceil(double a) //向上取整。返回大于等于参数的最小 double值
static double floor(double a) //向下取整。返回小于等于参数的最大 double值 
static double pow(double a, double b) //将第一个参数的值返回到第二个参数的幂。
static double sqrt(double a) //返回的正确舍入正平方根 double值。

其他方法（了解）

static double toDegrees(double angrad) //将以弧度测量的角度转换为以度为单位的近似等效角度。
static double toRadians(double angdeg) //将以度为单位的角度转换为以弧度测量的大致相等的角度。
static double tan(double a) //返回角度的三角正切。
static double tanh(double x) //返回的双曲正切 double值。
static double sin(double a) //返回角度的三角正弦。
static double sinh(double x) //返回的双曲正弦 double值。
static double cos(double a) //返回角度的三角余弦。
static double cosh(double x) //返回的双曲余弦 double值。
static double acos(double a) //返回值的反余弦值; 返回的角度在0.0到pi的范围内。
static double asin(double a) //返回值的正弦值; 返回角度在pi / 2到pi / 2的范围内。
static double atan(double a) //返回值的反正切值; 返回角度在pi / 2到pi / 2的范围内。
static double rint(double a) //返回与参数最接近值的 double值，并且等于数学整数,等同于floor。
static long	round(double a) //返回参数中最接近的 long ，其中 long四舍五入为正无穷大。等同于将参数四舍五入处理。下同。
static int round(float a) //返回参数中最接近的 int ，其中 int四舍五入为正无穷大。
    
static Object floorDiv(Object x, Object y) //返回小于等于x/y的商的最大 Object值。(Object为int或long)
static Object floorMod(Object x, Object y) //取模。返回 int参数的底部模数。但和平常的取余有所差别。见解释一(Object为int或long) 
static double hypot(double x, double y) //返回sqrt（ x^2 + y^2 ），没有中间溢出或下溢。

2、String类

int	length() //返回此字符串的长度。
boolean	isEmpty() //仅当 length()为 0返回 true。
boolean isBlank() //判断是否只包含空白字符（空格），是则返回 true。需要与判断为空区别开
char charAt(int index) //返回指定索引处的char值。
int	compareTo(String str) //按字典顺序比较两个字符串。前一个字符串大于后一个字符串则返回正数，否则返回负数；字符串相等，结果为零。他们的返回值是用的不等的字符处的ASCII码相减作为返回值。
String concat(String str) //将参数字符串连接到该字符串的末尾。

    
boolean	equals(Object anObject) //将此字符串与指定对象进行比较。
boolean	startsWith(String prefix) //测试此字符串是否以指定的前缀开头。
boolean	startsWith(String prefix, int toffset) //测试在指定索引处开始的此字符串的子字符串是否以指定的前缀开头。
boolean	endsWith(String suffix) //测试此字符串是否以指定的后缀结尾。
static String format(String format, Object... args) //使用指定的格式字符串和参数返回格式化的字符串。可以用来控制输出，如：System.out.println(String.format("%d %c", a,ch));
    
int	indexOf(int ch) //返回指定字符第一次出现的字符串内的索引。参数也可以是String类型
int	indexOf(int ch, int fromIndex) //返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索。参数也可以是String类型
int	lastIndexOf(int ch) //返回指定字符的最后一次出现的字符串中的索引。具体用法同indexOf
int	lastIndexOf(int ch, int fromIndex) //返回指定字符的最后一次出现的字符串中的索引，从指定的索引开始向后搜索。具体用法同indexOf
boolean	contains(CharSequence s) //当且仅当此字符串包含指定的char值序列时才返回true。可以简单的将CharSequence看成是String类型即可。传入String类型的字符串即可。
    
String replace(char oldChar, char newChar) //用newChar替换所有出现的oldChar字符串，并返回新的字符串。可以是单个字符。
String replaceFirst(String regex, String replacement) //只替换第一个匹配到的
    
String[] split(String regex) //将此字符串分割，用给定的regex的匹配。可以是正则表达式也可以是字符串
String[] split(String regex, int limit) //只分成limit个String，后面的不再分割。
    
CharSequence subSequence(int beginIndex, int endIndex) //返回一个子字符序列。不包括endindex
String substring(int beginIndex) //返回一个字符串，该字符串是此字符串的子字符串。
String substring(int beginIndex, int endIndex) //返回一个字符串，该字符串是此字符串的子字符串。 
char[] toCharArray() //将此字符串转换为新的字符数组。
    
String toLowerCase() //将字符串全部转换为小写
String toUpperCase() //将字符串全部转换为大写
String trim() //返回一个字符串，并删除任何前导和尾随空格。  
    
static String valueOf(Object obj) //将Object类型转换为String并返回。
static String valueOf(char[] data, int offset, int count) //返回 char数组参数的特定子阵列转换为字符串。
    
//了解即可
boolean	contentEquals(CharSequence cs) //将此字符串与指定的CharSequence进行 CharSequence，char值序列相同返回true，否则返回false 。可以简单看成是比较字符串。
    
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) //将此字符串中的字符复制到目标字符数组中。srcBegin - 要复制的字符串中第一个字符的索引。srcEnd - 要复制的字符串中最后一个字符后面的索引。dst - 目标数组。dstBegin - 目标数组中的起始偏移量。
    
int	codePointAt(int index) //返回指定索引处的字符的AScii码
int	codePointBefore(int index) //返回指定索引之前的字符ASCII码。
boolean	matches(String regex) //告诉这个字符串是否匹配给定的 regular expression 。

3、Integer包装类

System.out.println(Integer.MIN_VALUE); //返回最小值
System.out.println(Integer.MAX_VALUE);//返回最大值
 
toString(int i, int radix):String//将i转成radix进制的String字符串，并返回
toUnsignedString(int i, int radix):String//将i转成无符号的radix进制的String字符串，并返回
toHexString(int i):String//将i转成16进制的String字符串，并返回
toOctalString(int i):String//将i转成8进制的String字符串，并返回
toBinaryString(int i):String//将i转成2进制的String字符串，并返回
 
toString(int i):String//将i转成String字符串，并返回
toUnsignedString(int i):String//将i转成无符号的String字符串，并返回
 
parseInt(String s, int radix):int//将s看成radix进制的有符号整型，将其转化为十进制的int整型，并返回
parseInt(String s):int//将s转成十进制的int整型，并返回
parseUnsignedInt(String s, int radix)//将s看成无符号的radix进制的有符号整型，将其转化为十进制的int整型，并返回
parseUnsignedInt(String s)//调用parseUnsignedInt(s, 10)

4、Character包装类

//构造方法
Character(char value) //构造一个新分配的 Character对象，代表指定的 char值。
    
static int	compare(char x, char y) //数值比较两个 char数值。
 
    
static boolean	isDigit(char ch) //确定指定的字符是否是数字。
static boolean	isDigit(int codePoint) //确定指定的字符（Unicode代码点）是否为数字。
    
static boolean	isLetter(char ch) //确定指定的字符是否是一个字母。  
 
static boolean	isLetterOrDigit(char ch) //确定指定的字符是字母或数字。 
    
static boolean	isLowerCase(char ch) //确定指定的字符是否是小写字符。
 
static char	toLowerCase(char ch) //将字符参数转换为小写。
 
static boolean	isUpperCase(char ch) //确定指定的字符是否为大写字符。
 
static char	toUpperCase(char ch) //将字符参数转换为大写。
 
 
String toString()  //返回 String表示此对象 Character的价值。
static String	toString(char c) //返回一个 String对象，表示指定的 char。

5、Arrays类（数组处理）

static void	sort(Object[] a) //按照数字顺序排列指定的数组。
static void	sort(Object[] a, int fromIndex, int toIndex) //按升序排列数组的指定范围。
 
static int binarySearch(Object[] a, Object key) //使用二分查找指定元素的下标并返回，若不存在返回负值。
static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key) //在指定范围内使用二分查找
 
static boolean equals(Object[] a, Object[] a2) //如果两个指定的对象数组彼此相等，则返回 true。
 
static void	fill(Object[] a, Object val) //将指定的对象引用分配给指定的对象数组的每个元素。
static void	fill(Object[] a, int fromIndex, int toIndex, Object val) //将指定的对象引用分配给指定的对象数组的指定范围的每个元素。

了解

static void	parallelPrefix(Object[] array, IntBinaryOperator op) //使用提供的功能，并行地计算给定阵列的每个元素。op的用法见解释一。可以实现求前缀和。
static void	parallelPrefix(Object[] array, int fromIndex, int toIndex, IntBinaryOperator op) //对于数组的给定子范围执行 parallelPrefix(Object[], IntBinaryOperator) 。不包括后者。
    
static void	parallelSort(Object[] a) //按照数字顺序排列指定的数组。排序。
static void	parallelSort(Object[] a, int fromIndex, int toIndex) //按照数字顺序排列数组的指定范围。
    
static String toString(Object[] a) //返回指定数组的内容的字符串表示形式。
 
static Object[] copyOf(Object[] original, int newLength) //复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
static Object[] copyOfRange(Object[] original, int from, int to) //将指定数组的指定范围复制到新数组中。不包括后者。

6、Collections类（集合处理）

void reverse(List list)：//对指定 List 集合元素进行逆向排序。
void sort(List list)：//根据元素的自然顺序对指定 List 集合的元素按升序进行排序。
void sort(List list, Comparator c)：//根据指定 Comparator 产生的顺序对 List 集合元素进行排序。
void swap(List list, int i, int j)：//将指定 List 集合中的 i 处元素和 j 处元素进行交换。
 
void shuffle(List list)：//对 List 集合元素进行随机排序（shuffle 方法模拟了“洗牌”动作）。
void rotate(List list, int distance)：//当 distance 为正数时，将 list 集合的后 distance 个元素“整体”移到前面；当 distance 为负数时，将 list 集合的前 distance 个元素“整体”移到后面。该方法不会改变集合的长度。

7、BigInteger构造器(大整数)

String s = Scin.next(); //1561561561
BigInteger bs = new BigInteger(s);
System.out.println(bs); //1561561561


String s = Scin.next(); //10000
BigInteger bs = new BigInteger(s,2); //将字符串数字当成2进制
System.out.println(bs); //16

Long i = 100L;
BigInteger bs = BigIntegervalueOf(i)

BigInteger abs()  返回大整数的绝对值
BigInteger add(BigInteger val) 返回两个大整数的和
BigInteger subtract(BigInteger val)返回两个大整数相减的结果
BigInteger divide(BigInteger val)  返回两个大整数的商

double doubleValue()   返回大整数的double类型的值
float floatValue()   返回大整数的float类型的值

BigInteger gcd(BigInteger val)  返回大整数的最大公约数

int intValue() 返回大整数的整型值
long longValue() 返回大整数的long型值

BigInteger max(BigInteger val) 返回两个大整数的最大者
BigInteger min(BigInteger val) 返回两个大整数的最小者

BigInteger mod(BigInteger val) 用当前大整数对val求模
BigInteger multiply(BigInteger val) 返回两个大整数的积

BigInteger remainder(BigInteger val) 返回当前大整数除以val的余数

String toString() 将当前大整数转换成十进制的字符串形式

8、BigDecimal类（大浮点数）

import java.math.BigDecimal;
 
public class Main {
 
	public static void main(String[] args) {
		BigDecimal d1 = new BigDecimal("3.1415926535");
		BigDecimal d2 = new BigDecimal("2.7182818284");
		BigDecimal d3 = d1.divide(d2, 10, BigDecimal.ROUND_UP);
		System.out.println(3.1415926535 / 2.7182818284);
		System.out.println(d3);
	}
}

三、单列集合

1、Collection接口

1.1、概述

 Collection是单列集合的顶级接口(interface)

1.2、特点

a.元素有序
b.元素可重复
c.没有索引

1.3、创建

Collection<E> 集合名 = new ArrayList<E>()

1.4、方法介绍

1、boolean add(E e) : 将给定的元素添加到当前集合中(我们一般调add时,不用boolean接收,因为add一定会成功)
2、boolean addAll(Collection<? extends E> c) :将另一个集合元素添加到当前集合中 (集合合并)
3、void clear():清除集合中所有的元素
4、boolean contains(Object o)  :判断当前集合中是否包含指定的元素
5、boolean isEmpty() : 判断当前集合中是否有元素->判断集合是否为空
6、boolean remove(Object o):将指定的元素从集合中删除
7、int size() :返回集合中的元素数。
8、Object[] toArray(): 把集合中的元素,存储到数组中

public class Test01 {
    public static void main(String[] args) {
        Collection<String> collection1 = new ArrayList<String>();
        //boolean add(E e) : 将给定的元素添加到当前集合中(我们一般调add时,不用boolean接收,因为add一定会成功)
        collection1.add("张无忌");
        collection1.add("赵敏");
        collection1.add("周芷若");
        collection1.add("灭绝师太");
        collection1.add("金毛狮王");
        collection1.add("青翼蝠王");
        collection1.add("白眉鹰王");
        collection1.add("紫衫龙王");
        System.out.println(collection1);
        //boolean addAll(Collection<? extends E> c) :将另一个集合元素添加到当前集合中 (集合合并)
        Collection<String> collection2 = new ArrayList<String>();
        collection2.add("乔峰");
        collection2.add("段誉");
        collection2.add("虚竹");

        collection1.addAll(collection2);
        System.out.println(collection1);
        //void clear():清除集合中所有的元素
        //collection1.clear();
        //System.out.println(collection1);

        //boolean contains(Object o)  :判断当前集合中是否包含指定的元素
        boolean result01 = collection1.contains("赵敏");
        System.out.println("result01 = " + result01);
        //boolean isEmpty() : 判断当前集合中是否有元素->判断集合是否为空
        boolean empty = collection1.isEmpty();
        System.out.println("empty = " + empty);
        //boolean remove(Object o):将指定的元素从集合中删除
        boolean result02 = collection1.remove("周芷若");
        System.out.println("result02 = " + result02);
        System.out.println(collection1);
        //int size() :返回集合中的元素数。
        System.out.println(collection1.size());
        //Object[] toArray(): 把集合中的元素,存储到数组中
        Object[] array = collection1.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

2、List

2.1、概述

List接口是Collection接口的子接口

2.2、实现类

ArrayList,LinkedList,Vector

3、ArrayList

3.1、概述

概述:ArrayList是List接口的实现类

3.2、特点

a.元素有序
b.元素可重复
c.有索引
d.线程不安全

3.3、数据结构

数据结构：数组

3.4、常用方法

1、boolean add(E e)  -> 将元素添加到集合中->尾部(add方法一定能添加成功的,所以我们不用boolean接收返回值)    
2、void add(int index, E element) ->在指定索引位置上添加元素
3、boolean remove(Object o) ->删除指定的元素,删除成功为true,失败为false  
4、E remove(int index) -> 删除指定索引位置上的元素,返回的是被删除的那个元素  
5、E set(int index, E element) -> 将指定索引位置上的元素,修改成后面的element元素  
6、E get(int index) -> 根据索引获取元素
7、int size()  -> 获取集合元素个数

3.4.1、remove方法注意事项

public class Test03_ArrayList {
  public static void main(String[] args) {
      ArrayList<Integer> list = new ArrayList<>();
      list.add(2);
      /*
         remove(Object o)-> 删除指定元素
         remove(int index)->删除指定索引位置上的元素

         remove(2)-> 2是一个int型->自动匹配到了remove(int index)->删除指定索引位置上的元素

         但是list集合中没有2索引,所以报错
       */
      //list.remove(2);

      list.remove(new Integer(2));
      System.out.println(list);
  }
}

3.5、底层实现原理

1.问题:我们说过ArrayList是一个集合,集合的长度是可变的;ArrayList底层数据结构是数组,那么底层数据结构是数组怎么做到长度可变的呢?
    
2.ArrayList有一个空参构造:
  ArrayList() 构造一个初始容量为 10 的空列表
  
  注意:不是一new就创建一个长度为10的空列表,而是第一次add的时候才会创建长度为10的空列表
      
3.为啥说ArrayList底层是个数组,但是还要说ArrayList是长度可变的呢?
  elementData = Arrays.copyOf(elementData, newCapacity);->数组扩容,数组复制

4.怎么扩容的?
  elementData = Arrays.copyOf(elementData, newCapacity);->数组扩容,数组复制
      
5.扩容多少倍呢? 
  1.5倍    

4、LinkedList

4.1、概述

是List接口下的实现类

4.2、特点

a.元素有序 b.元素可重复 c.有索引 d.线程不安全

4.3、数据结构

我们有可能有大量的首尾元素的操作,LinkedList有很多特有方法,这些特有方法都是直接操作首尾元素的

4.4、使用场景

我们有可能有大量的首尾元素的操作,LinkedList有很多特有方法,这些特有方法都是直接操作首尾元素的

4.5、方法

4.5.1、方法（和ArrayList方法相同）

1、boolean add(E e)  -> 将元素添加到集合中->尾部(add方法一定能添加成功的,所以我们不用boolean接收返回值)
2、void add(int index, E element) ->在指定索引位置上添加元素
3、boolean remove(Object o) ->删除指定的元素,删除成功为true,失败为false  
4、E remove(int index) -> 删除指定索引位置上的元素,返回的是被删除的那个元素  
5、E set(int index, E element) -> 将指定索引位置上的元素,修改成后面的element元素  
6、E get(int index) -> 根据索引获取元素  
7、int size()  -> 获取集合元素个数

4.5.2 特有方法

1、 public void addFirst(E e):将指定元素插入此列表的开头。
2、 public void addLast(E e):将指定元素添加到此列表的结尾。
3、 public E getFirst():返回此列表的第一个元素。
4、 public E getLast():返回此列表的最后一个元素。  
5、 public E removeFirst():移除并返回此列表的第一个元素。
6、 public E removeLast():移除并返回此列表的最后一个元素。  
7、 public E pop():从此列表所表示的堆栈处弹出一个元素。  
8、 public void push(E e):将元素推入此列表所表示的堆栈。 
9、 public boolean isEmpty()：如果列表不包含元素，则返回true。

4.6、底层原理

4.6.1、LinkedList底层成员解释说明

1.LinkedList底层成员
  transient int size = 0;  元素个数
  transient Node<E> first; 第一个节点对象
  transient Node<E> last;  最后一个节点对象
  
2.Node代表的是结点对象
   private static class Node<E> {
        E item;//节点上的元素
        Node<E> next;//记录着下一个节点地址
        Node<E> prev;//记录着上一个节点地址

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

4.6.2、LinkedList中add方法源码分析

LinkedList<String> list = new LinkedList<>();
list.add("a");
list.add("b");    

void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
}

4.6.3、查询速度

为了查询速度快：采用二分法查找思想

5、Vector

5.1、概述

是Collection的实现类,从jdk1.0版本开始就有了,但是由于效率低,从jdk1.2开始变成了Collection实现类

5.2、特点

a.有序
b.有索引
c.元素可重复
d.线程安全

5.3、数据结构

数组

5.4、方法

因为不经常使用，方法不在一一例举
方法同 ArrayList 

5.5、底层原理

a.Vector一new底层就会直接产生一个长度为10的空数组
b.数组扩容:Arrays.copyOf
    扩容2倍 

6、Set

6.1、概述

Set是一个接口,是Collection下的子接口

6.2、方法

a.所有的方法和 Collection 接口中的方法一毛一样
  
b.set接口中的方法并没有对Collection中的方法进行任何的扩充

c.Set以及下面所有的实现类集合相当于是一个"傀儡"
    因为所有的set集合底层都是依靠map集合实现的

7、HashSet

7.1、概述

HashSet 是 Set接口的实现类对象

7.2、特点

a.元素无序
b.元素不可重复
c.无索引
d.线程不安全

7.3、数据结构

哈希表
jdk8之前: 哈希表 = 数组+链表
jdk8之后: 哈希表 = 数组+链表+红黑树

7.4、方法

和Collection一毛一样

1、boolean add(E e) : 将给定的元素添加到当前集合中(我们一般调add时,不用boolean接收,因为add一定会成功)
2、boolean addAll(Collection<? extends E> c) :将另一个集合元素添加到当前集合中 (集合合并)
3、void clear():清除集合中所有的元素
4、boolean contains(Object o)  :判断当前集合中是否包含指定的元素
5、boolean isEmpty() : 判断当前集合中是否有元素->判断集合是否为空
6、boolean remove(Object o):将指定的元素从集合中删除
7、int size() :返回集合中的元素数。
8、Object[] toArray(): 把集合中的元素,存储到数组中

7.5、如何做到元素唯一

重写hashCode和equals方法
a.先计算元素哈希值进行比较,再比较内容
b.如果哈希值不一样,存
c.如果哈希值一样,再比较内容
d.如果哈希值一样,内容不一样,存
e.如果哈希值一样,内容一样,元素覆盖
f.后面覆盖前面

8、LinkedHashSet

8.1、概述

LinkedHashSet extends HashSet

8.2、特点

a.元素有序
b.元素不可重复
c.无索引
d.线程不安全

8.3、数据结构

哈希表+双向链表

8.4、方法

和HashSet一样

1、boolean add(E e) : 将给定的元素添加到当前集合中(我们一般调add时,不用boolean接收,因为add一定会成功)
2、boolean addAll(Collection<? extends E> c) :将另一个集合元素添加到当前集合中 (集合合并)
3、void clear():清除集合中所有的元素
4、boolean contains(Object o)  :判断当前集合中是否包含指定的元素
5、boolean isEmpty() : 判断当前集合中是否有元素->判断集合是否为空
6、boolean remove(Object o):将指定的元素从集合中删除
7、int size() :返回集合中的元素数。
8、Object[] toArray(): 把集合中的元素,存储到数组中

8.5、 如何做到元素唯一

重写hashCode和equals方法
a.先计算元素哈希值进行比较,再比较内容
b.如果哈希值不一样,存
c.如果哈希值一样,再比较内容
d.如果哈希值一样,内容不一样,存
e.如果哈希值一样,内容一样,元素覆盖
f.后面覆盖前面

9、TreeSet

9.1、概述

TreeSet是Set接口的实现类

9.2、特点

a.可以对元素进行排序
b.元素唯一
c.无索引
d.线程不安全

9.3、数据结构

红黑树

9.4、方法

和HashSet一样

1、boolean add(E e) : 将给定的元素添加到当前集合中(我们一般调add时,不用boolean接收,因为add一定会成功)
2、boolean addAll(Collection<? extends E> c) :将另一个集合元素添加到当前集合中 (集合合并)
3、void clear():清除集合中所有的元素
4、boolean contains(Object o)  :判断当前集合中是否包含指定的元素
5、boolean isEmpty() : 判断当前集合中是否有元素->判断集合是否为空
6、boolean remove(Object o):将指定的元素从集合中删除
7、int size() :返回集合中的元素数。
8、Object[] toArray(): 把集合中的元素,存储到数组中

9.5、构造方法

TreeSet()  -> 对元素进行自然排序-> ASCII
TreeSet(Comparator<? super E> comparator) -> 按照指定规则进行排序

9.6、demo

public class Person {
    private String name;
    private Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class Demo01TreeSet {
    public static void main(String[] args) {
        TreeSet<String> set = new TreeSet<>();
        set.add("b");
        set.add("a");
        set.add("d");
        set.add("c");
        System.out.println(set);

        System.out.println("=========================");

        TreeSet<Person> set1 = new TreeSet<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        set1.add(new Person("涛哥",12));
        set1.add(new Person("柳岩",36));
        set1.add(new Person("曼曼",26));
        System.out.println(set1);
    }
}
	

四、双列集合

1、Map

1.1、概述

1.概述:双列集合的顶级接口
2.组成部分:
  一个元素是有两部分构成
  key = value  -> 键值对

2、HashMap

2.1、概述

是Map的实现类

2.2、特点

a.元素无序
b.key唯一,value可重复
c.无索引
d.线程不安全
e.能存null键null值

2.3、数据结构

哈希表

2.4、方法

1、V put(K key, V value)  -> 存储元素
2、V remove(Object key)  ->根据key删除对应的键值对 
3、V get(Object key)  -> 根据key获取对应的value 
4、boolean containsKey(Object key) ->判断Map中是否包含指定的key  
5、Collection<V> values()  -> 将Map中所有的value存储到Collection集合中  
6、Set<K> keySet() -> 将Map中所有的key获取出来存到Set集合中 
7、Set<Map.Entry<K,V>> entrySet() -> 获取Map中所有的键值对对象,放到set集合中

2.5、注意

如果key重复了,后面的会把前面的覆盖掉,去重复过程和set一毛一样

public class Test01_HashMap {
    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        //V put(K key, V value)  -> 存储元素
        hashMap.put("涛哥","柳岩");
        hashMap.put("黄晓明","杨颖");
        hashMap.put("文章","马伊琍");
        hashMap.put("文章","姚笛");
        hashMap.put("宝强","马蓉");
        hashMap.put("宋喆","马蓉");
        System.out.println(hashMap);
        //V remove(Object key)  ->根据key删除对应的键值对
        String value = hashMap.remove("涛哥");
        System.out.println(value);
        System.out.println(hashMap);
        //V get(Object key)  -> 根据key获取对应的value
        String value1 = hashMap.get("黄晓明");
        System.out.println(value1);
        //boolean containsKey(Object key) ->判断Map中是否包含指定的key
        boolean result = hashMap.containsKey("涛哥");
        System.out.println("result = " + result);
        //Collection<V> values()  -> 将Map中所有的value存储到Collection集合中

        Collection<String> collection = hashMap.values();
        for (String s : collection) {
            System.out.println(s);
        }
    }
}

2.6、如果做到key唯一

key重写hashCode和equals方法
    a.先计算元素哈希值进行比较,再比较内容
    b.如果哈希值不一样,存
    c.如果哈希值一样,再比较内容
    d.如果哈希值一样,内容不一样,存
    e.如果哈希值一样,内容一样,元素覆盖
        后面覆盖前面

3、LinkedHashMap

3.1、概述

LinkedHashMap extends HashMap

3.2、特点

a.有序
b.无索引
c.key唯一,value可重复
d.线程不安全
e.能存null键null值

3.3、数据结构

哈希表+双向链表

3.4、方法

和HashMap一样

1、V put(K key, V value)  -> 存储元素  
2、V remove(Object key)  ->根据key删除对应的键值对  
3、V get(Object key)  -> 根据key获取对应的value  
4、boolean containsKey(Object key) ->判断Map中是否包含指定的key 
5、Collection<V> values()  -> 将Map中所有的value存储到Collection集合中 
6、Set<K> keySet() -> 将Map中所有的key获取出来存到Set集合中 
7、Set<Map.Entry<K,V>> entrySet() -> 获取Map中所有的键值对对象,放到set集合中

3.5、如果做到key唯一

key重写hashCode和equals方法
    a.先计算元素哈希值进行比较,再比较内容
    b.如果哈希值不一样,存
    c.如果哈希值一样,再比较内容
    d.如果哈希值一样,内容不一样,存
    e.如果哈希值一样,内容一样,元素覆盖
        后面覆盖前面

4、TreeMap

4.1、概述

TreeMap是Map接口的实现类

4.2、特点

    a.key唯一
    b.可以对key进行排序
    c.无索引
    d.线程不安全
    e.能存null键null值

4.3、数据结构

红黑树

4.4、方法

和HashMap一样

1、V put(K key, V value)  -> 存储元素
2、V remove(Object key)  ->根据key删除对应的键值对
3、V get(Object key)  -> 根据key获取对应的value 
4、boolean containsKey(Object key) ->判断Map中是否包含指定的key 
5、Collection<V> values()  -> 将Map中所有的value存储到Collection集合中 
6、Set<K> keySet() -> 将Map中所有的key获取出来存到Set集合中  
7、Set<Map.Entry<K,V>> entrySet() -> 获取Map中所有的键值对对象,放到set集合中

4.5、构造方法

TreeMap() -> 按照自然顺序对key进行排序
TreeMap(Comparator<? super K> comparator)-> 按照指定规则对key进行排序 

4.6、demo

public class Person {
    private String name;
    private Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class Demo02TreeMap {
    public static void main(String[] args) {
        TreeMap<String, String> treeMap = new TreeMap<>();
        treeMap.put("b","疑是地上霜");
        treeMap.put("d","低头思故乡");
        treeMap.put("a","床前明月光");
        treeMap.put("c","举头望明月");
        System.out.println(treeMap);

        System.out.println("========================");

        TreeMap<Person, String> treeMap1 = new TreeMap<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        treeMap1.put(new Person("涛哥",10),"廊坊");
        treeMap1.put(new Person("柳岩",36),"湖南");
        treeMap1.put(new Person("曼曼",26),"东北");
        System.out.println(treeMap1);
    }
}

5、Hashtable

5.1、概述

是Map的实现类,从jdk1.0开始就有,但是由于效率低,所以从jdk1.2开始变成了map的实现类

5.2、特点

1.特点
      a.无序
      b.key唯一,value可重复
      c.无索引
      d.线程安全
      e.不能存储null键,null值

5.3、数据结构

哈希表

5.4、方法

和HashMap一样

1、V put(K key, V value)  -> 存储元素
2、V remove(Object key)  ->根据key删除对应的键值对
3、V get(Object key)  -> 根据key获取对应的value
4、boolean containsKey(Object key) ->判断Map中是否包含指定的key
5、Collection<V> values()  -> 将Map中所有的value存储到Collection集合中 
6、Set<K> keySet() -> 将Map中所有的key获取出来存到Set集合中  
7、Set<Map.Entry<K,V>> entrySet() -> 获取Map中所有的键值对对象,放到set集合中

6、Properties

6.1、概述

Properties是Hashtable的子类

6.2、特点

      a.无序
      b.key唯一,value可重复
      c.无索引
      d.线程安全
      e.Properties的key和value类型默认是String
      f.不允许有null键null值

6.3、数据结构

哈希表

6.4、方法

6.4.1、方法

和HashMap一样

1、V put(K key, V value)  -> 存储元素 
2、V remove(Object key)  ->根据key删除对应的键值对 
3、V get(Object key)  -> 根据key获取对应的value 
4、boolean containsKey(Object key) ->判断Map中是否包含指定的key 
5、Collection<V> values()  -> 将Map中所有的value存储到Collection集合中 
6、Set<K> keySet() -> 将Map中所有的key获取出来存到Set集合中 
7、Set<Map.Entry<K,V>> entrySet() -> 获取Map中所有的键值对对象,放到set集合中

6.4.2、特有方法

1、 Object setProperty(String key, String value)  -> 存储键值对
2、 String getProperty(String key)  -> 根据key获取value
3、 Set<String> stringPropertyNames()  -> 获取所有的key,存放到Set集合中
4、 void load(InputStream inStream)  ->  将流中的数据信息加载到Properties集合中 (IO流部分讲)

五、

1、迭代器

Iterator
	a.获取
		Collection中的方法
			Iterator iterator()
	b.方法
		hasNext()
			判断有没有下一个元素
		next()
			获取下一个元素
	c.并发修改异常
		实际操作次数和预期操作次数不相等

2、增强for

2.增强for
	a.格式
		for(元素类型 变量名:集合名或者数组名){}
	b.注意
		遍历集合时,原理为迭代器
		遍历数组时,原理为普通for

3、泛型

3.泛型
	a.含有泛型的类
		public class 类名<E>{}
		new对象时确定类型
	b.含有泛型的方法
		修饰符 <E> 返回值类型 方法名(E e){}
		调用的时候确定类型
	c.含有泛型的接口
		public interface 接口名<E>{}
		实现类时候确定类型
		new实现类对象的时候确定类型
	d.泛型高级使用
		上限
			<? extends 类>
				?接收的类型为后面类的本类以及子类
		下限
			<? super 类>
				?接收的类型为后面类的本类以及父类

4、Collections集合工具类

4.Collections集合工具类
	  static <T> boolean addAll(Collection<? super T> c, T... elements)->批量将元素存到集合中
	  static void shuffle(List<?> list) -> 将集合中的元素顺序打乱 
	  static  <T> void sort(List<T> list) ->将集合中的元素按照默认规则排序->ASCII
	  static <T> void sort(List<T> list, Comparator<? super T> c)->将集合中的元素按照指定规则排序 

5、数据结构

   栈
        先进后出
    队列
        先进先出
    数组
        查询快
        增删慢
    链表
        查询慢
        增删快