Java集合与常用类基本知识总结

基本知识总结"/>

Java集合与常用类基本知识总结

一.集合(Colleection)

1)集合中的继承关系图

2)Collection集合 (集合的最大接口)

1）JDK不提供此接口的任何直接实现，他提供更具的子接口（子实现类）实现
2）基本功能:*添加：boolean add(Object e):添加任意的引用类型元素*删除：boolean remove(Object e):删除指定的元素void clear():清空集合中的所有元素*判断：boolean contains(Object o):判断是否包含指定的元素 包含就返回true，否则返回falseboolean isEmpty()：判断集合是否为空，如果为空，则返回true，否则false	*获取：int size():获取集合中的元素数int  set():表示获取集合中的元素数Object[] toArray():将集合进行遍历--->将集合转换成数组遍历（传统方式）Iterator<Object> iterator() ：获取Collection的集合的迭代器（Collection接口的专有遍历方式）
3）高级功能：*添加：boolean addAll(Collection c):添加一个集合的元素
/*System.out.println("addAll():"+c1.addAll(c2)); //输出集合元素,将c2集合中的元素全部添加到c1中.
*/*删除：boolean removeAll(Collection c):删除一个集合的元素
/*System.out.println("removeAll():"+c1.removeAll(c2));//在c1集合中删除重复的c2的一个元素就算删除
*/        *包含：boolean containsAll(Collection c):包含集合中的元素
/*System.out.println("containsAll():"+c1.containsAll(c2));//包含一个集合中的所有的元素才返回true
*/        *针对集合交集boolean retainAll(Collection c):针对集合交集  
/*//A集合对B集合取交集,交集的元素给A集合,返回值boolean表达的意思//A集合的元素前后是否发生变化,如果没有变化,返回false，如果有变化,则返回true;System.out.println("retainAll():"+c1.retainAll(c2));
*/3)Itetator:(迭代器接口)用于遍历集合中元素的接口，主要包含三种方法：Object next() :获取下一个元素boolean hasNext():如果存在一个元素,使用next()获取下一个元素default void remove():从基础集合中移除这个迭代器返回的最后一个元素
4)Collection:集合的遍历*迭代器：本质是一种接口多态的方式,来实现迭代器进行实例化*Itetator<Object> iterator():集合中专有的遍历方式*使用格式:/*Iterator it = c.iterator() ;//获取迭代器的对象while(it.hasNext()) {String s  =(String) (it.next()) ;System.out.println(s+"---"+s.length());}}*/
5)使用注意事项:*集合获取迭代器的时候,集合里面存储的类型是什么类型,心里要清楚,转换会出现类转换异常(没有使用泛型!)*next()不能使用多次 ,结果不匹配(next()使用拿到了迭代器中所有的对象)  Object obj = 迭代器对象.next();

3)List集合(Collection集合中的子接口)

1）List集合：是Collection的子接口(基本功能以及高级功能都可以继承过来)
2)特点：*有序，存储和取出一致*该集合可以允许元素重复
3)List特有功能：*添加：void add(int index,Object element):在指定的位置处添加新的元素*删除：Object remove(int index)：删除指定位置处的元素，返回该元素*获取：Object get(int index):跟据索引值获取指定元素*设置元素：Object set(int index,Object element):指定位置处，使用新的元素去替该位置处的元素
4）ListIterator(Itetartor迭代器接口的子接口))(List集合的专有遍历方式：列表迭代器)*列表迭代器：ListInterator lit = list.listInterator();*ListInterator接口方法：列表迭代器中有一个add(Object e):可以使用迭代器去添加元素*ListInterator接口功能：**正向遍历：boolean hacNext():判断是否存在下一个元素Object  next():   获取下一个元素**逆向遍历（单独使用无意义，下必须先使用正向遍历，才能使用逆向遍历）：boolean hasPrevious():判断是否存在上一个元素Object  previous():获取上一个元素5)List集合使用://代码示例//创建一个List集合对象List list = new ArrayList() ;//添加元素list.add("hello") ;list.add("world") ;list.add("java") ;list.add("javaee") ;System.out.println(list);//void add(int index,Object element):在指定的位置处添加新的元素list.add(2, "android");//Object remove(int index):删除指定位置处的元素,返回该元素list.remove(4) ;//Object get(int index):根据索引值获取指定的元素System.out.println("get():"+list.get(2));//Object set(int index, Object element)System.out.println("set():"+list.set(3, "goLang"));System.out.println(list);System.out.println("--------------------------");//新的方式:size()和get(int index)方法相结合遍历:普通forfor(int x = 0 ;x < list.size(); x ++) {//获取元素//Object object = list.get(x) ; //向上转型:Object object = new String() ;//获取字符串以及字符串长度String s = (String)(list.get(x)) ;System.out.println(s+"---"+s.length());}6)一个异常处理:// 需求:创建List集合对象,如果当前集合中存在一个"world"元素,给集合中添加一个新的元素"javaee" ;
/** java.util.ConcurrentModificationException:使用迭代器遍历集合,不能使用集合操作元素!* 并发修改异常:* 		并发:在同一个时间点上同时发生 ------>高并发* 		并行:在同一个时间段内同时发生* * 集合中出现异常:* 		使用迭代器遍历集合,在同时使用集合对象操作元素,就会出现这个异常!* 		迭代器遍历集合元素,集合添加元素,而对于迭代器对象并不知道存在一个新的元素!* * 如何解决呢?* 		1)迭代器遍历集合,迭代器添加元素 :ListIterator存在添加功能* 		2)集合遍历,集合添加 :普通for循环:(size()和get(int index)相结合)* * */
public class ListIteratorTest {public static void main(String[] args) {//创建一个List集合对象,本身存在三个元素"hello","world","java"List list = new ArrayList() ;//添加元素list.add("hello") ;list.add("world") ;list.add("java") ;		//使用Collection的迭代器Iterator()/*Iterator it = list.iterator() ;while(it.hasNext()) {//获取元素String s = (String)(it.next()) ;//判断if("world".equals(s)) {//使用集合添加新的元素list.add("javaee") ;}}System.out.println(list);*///方案1:使用迭代器遍历集合,迭代器操作元素/*ListIterator lit  = list.listIterator() ;//遍历while(lit.hasNext()) {String s = (String)(lit.next()) ;//判断if("world".equals(s)) {//使用迭代器添加元素lit.add("javaee");}}System.out.println(list);*//*//方案2:使用集合遍历,集合添加(推荐)for(int x = 0 ; x < list.size() ; x ++) {String s = (String)(list.get(x)) ;if("world".equals(s)) {//集合添加list.add("javaee") ;}}System.out.println(list);*/}
}7)List集合中添加重复字符串元素---->去重(两种方法):*第一种方法:/*//集合去重（旧集合中有重复元素，需要将集合去重）//第一种方法* 		使用新集合与旧集合相比较,旧集合中每一个元素与新集合比较,如有重复,进行下一个旧集合元素的* 		比较,若没有重复,则将旧集合中的此元素插入新集合.*/@SuppressWarnings("all")public class DuplicateChecking1 {public static void main(String[] args) {List<String> list = new ArrayList<String>();//存储旧的集合list.add("hello");list.add("world");list.add("hello");list.add("world");//集合查重//定义新集合List<String> list2 = new ArrayList<String>();//查重for (int i = 0; i < list.size(); i++) {if(!(list2.contains(list.get(i)))) {list2.add(list.get(i));}}//遍历查重之后的集合//方法一:普通迭代器遍历/*ListIterator<String> iterator = list2.listIterator();while(iterator.hasNext()) {String str = iterator.next();System.out.println(str+"--"+str.length());}*///方法二:for增强循环遍历for (String string : list2) {System.out.println(string.toString());}}}*第二种方法:/*集合去重（旧集合中有重复元素，需要将集合去重）* * 第二种方法 -->使用选择排序的思想:* * 				1)第一个集合元素和剩余的集合元素比较,如果第一个与剩余的集合元素* 				中有重复的,使用remove(指定为之元素下标):方法删除此元素.* 				2)重复如上操作,依次而行,便可去除所有重复元素*/@SuppressWarnings("all")public class DuplicateChecking2 { public static void main(String[] args) {List<String> list = new ArrayList<String>();//存储旧的集合list.add("hello");list.add("world");list.add("hello");list.add("world");list.add("王伟");list.add("王伟");//集合查重//旧集合查重,使用选择排序思想for (int i = 0; i < list.size(); i++) {for (int j = i + 1 ; j < list.size(); j++) {if((list.get(i)).contains(list.get(j))) {list.remove(j);}}}for (String str: list) {System.out.println(str.toString());}}}
8)集合存储遍历(五种方式)package com.qianfeng2;import java.util.ArrayList;import java.util.Iterator;import java.util.List;import java.util.ListIterator;public class ListDemo {public static void main(String[] args) {List<Student> list = new ArrayList<Student>();list.add(new Student("王昭君",1230));list.add(new Student("西施",2210));list.add(new Student("貂蝉",2230));list.add(new Student("杨玉环",2000));//第一种 toArray()Object[] array = list.toArray();for (int i = 0; i < array.length; i++) {Student s = (Student) array[i];System.out.println(s.toString());}System.out.println("---------------------------");//第二种 Collection 专有的 迭代器 :Iterator iterator()Iterator<Student> it = list.iterator();while(it.hasNext()) {Student st = it.next();System.out.println(st.toString());}System.out.println("---------------------------");//第三种 list专有的get()方法for (int i = 0; i < list.size(); i++) {Student stu = list.get(i);System.out.println(stu.toString());}System.out.println("---------------------------");//第四种方法  列表迭代器：ListInterator lit = list.listInterator();ListIterator<Student> it1 = list.listIterator();while(it1.hasNext()) {Student stu1 = it1.next();System.out.println(stu1.toString());}System.out.println("---------------------------");//第五种方法 : 增强for循环（JDK5的新特性）for (Student stu2 : list) {System.out.println(stu2.toString());}}}

4)ArrayList集合(继承与List集合,是List(接口)集合三个子实现类中之一)

1)数据结构*大小可变的数据实现(默认容量是10,扩容性1.5倍)*底层数据结构是数组,查询快,增删慢*线程角度(执行效率):线程是不安全的,不同步的--->(单线程中)执行性效率高
2)功能:*构造方法:public ArrayList():构造一个初始容量为10的空列表。public ArrayList(int initialCapacity):用指定的初始容量构造一个空列initialCapacity -列表的初始容量 public ArrayList(Collection<? extends E> c):构造一个包含指定集合的元素的列表，它们在集合的迭代器返回的顺序中返回.c的元素都被放置到这个名单的收集 *常用功能:添加元素:public boolean add(E e):添加元素public void add(int index,E element):在列表中指定的位置上插入指定的元素。将当前处于该位置（如果有的话)和任何后续元素的元素移到右边（添加一个到它们的索引）。 删除:public E remove(int index):移除此列表中指定位置的元素。所有后续元素左移（下标减1）。 public void clear():从这个列表中移除所有的元素。此调用返回后的列表将是空的。 
3)使用:*存储自定义对象并遍历(四种方法):<day17笔记中第六个大点>	1>Collection的迭代器2>List的列表迭代器3>Object get(int index)/size():普通for循环4>增强for循环	
##一般,开发中没有告诉使用什么集合,一般默认使用ArrayList集合/*ArrayList集合去除重复的自定义对象元素
package com.qianfeng.arraylist_01;
import java.util.ArrayList;/** * 需求:* 使用ArrayList添加重复的对象类型(自定义对象),如何去除重复自定义对象!*如果该自定义对象的成员信息一致,认为同一个人!**contains()底层依赖于equals()方法,而equals方法*			this.equals(Object s):如果没有重写Object类中的equals方法,默认比较的是地址值*是否相同,目前这个类Student类(自定义类)**如果想将重复的对象去除掉,需要在自定义的类中重写Object类中equals方法(),让它比较*成员信息是否一致!* * */public class ArrayTest3 {public static void main(String[] args) {		//创建ArrayList集合对象ArrayList<Student> array = new ArrayList<Student>() ;		//创建几个学生对象Student s1 = new Student("高圆圆", 28) ;Student s2 = new Student("高圆圆", 28) ;Student s3 = new Student("高圆圆", 39) ;Student s4 = new Student("赵又廷", 44) ;Student s5 = new Student("文章", 30) ;Student s6 = new Student("邓超", 39) ;Student s7 = new Student("邓超", 39) ;//给旧集合添加array.add(s1) ;array.add(s2) ;array.add(s3) ;array.add(s4) ;array.add(s5) ;array.add(s6) ;array.add(s7) ;		//创建一个新的集合ArrayList<Student> newArray = new ArrayList<Student>() ;		//遍历旧集合for(Student s: array) {			//使用新集合判断是否包含元素if(!newArray.contains(s)) {//将学生对象添加到新集合中newArray.add(s) ;}}//遍历新集合for(Student s:newArray){System.out.println(s.getName()+"---"+s.getAge());}}	}*/

5)LinkedList集合(继承与List集合,是List(接口)集合三个子实现类中之一)

LinkedList:(应用场景:用户浏览过的商品足迹id)1)数据结构*类似于栈结构的特点(先进先出)*底层数据结构是链表实现,查询慢,增删快*线程角度(执行效率):线程是不安全的,不同步的--->执行性效率高2)应用:*添加功能:public void addFirst(Object e):添加元素到列表的开头public void addLast(Object e):添加元素到末尾*删除功能public Object removeFirst():移除此列表的开头元素public Object removeLast():移除末尾的元素 *获取功能:public Object getFirst():获取列表开头public Object getLast() :获取列表末尾*给链接列表开头添加元素:addFirst()获取元素:getFirst()*栈操作:pop():弹栈,弹栈出第一个元素push(Object e):压栈,给栈中添加一个元素(推入一个元素在列表开头)            

6)Vector集合(继承与List集合,是List(接口)集合三个子实现类中之一)

Vector:
1)数据结构*底层数据结构是数组,查询快,增删慢*线程角度(执行效率):线程是安全的,同步的--->(单线程中)执行性效率低
2)应用:*特有功能:public Enumeration<E> elements(): 获取Vector集合的迭代器(向量的组件枚举)----public Iterator iterator() public Object elementAt(int index):获取指定位置处的组件----->Object get(int index)##Enumeration接口里面有两个抽象方法:boolean hasMoreElements():判断是否包含很多的元素----  boolean hasNext()Object nextElement():获取下一个元素 ---Object next()   		

7)Set集合(继承与Collection接口)及其子实现类

1)HashSet:无序不可重复 *数据结构** 不能保证元素的迭代顺序恒久不变** 底层数据结构是哈希表(哈希表能够保证元素唯一)*应用:**哈希表能够保证元素唯一:依赖于  public int hashCode() 方法 和  public boolean equals(Object e)方法**HashSet的add方法依赖于-->HashMap的put方法依赖于--> HashCode()方法和equals(Object e)方法2)TreeSet(重点):有两种排序(自然排序/比较器排序)*数据结构:**基于TreeMap的一个红黑树结构(Red-Black-Tree)(是一种二叉树结构)*应用:**自然排序:使用无参构造方法:public TreeSet():构造一个新的、空的树集，根据其元素的自然排序进行排序。所有的元素插入设定必须实Comparable接口。此外，所有这些元素必须相互比较： e1pareTo(e2)不得把任何元素 e1和 e2集合中的ClassCastException。如果用户试图违反此约束集合添加一个元素（例如，用户尝试一系列的元素添加一个字符串，整数单元）的 add称将 ClassCastException。 注意:在自定义的类中需要手动实现继承Comparable接口,并且手动重写compareTo()方法.在非自定义的类中已经继承了Comparable接口,已经重写了compareTo()方法**选择器排序:使用有参构造方法:public TreeSet(Comparator<? super E> comparator):构造一个新的、空的树集，根据指定的比较器进行排序。所有的元素插入到集合必须相互比较由指定的比较器comparatorpare(e1, e2)必须不把任何 一个元素 e1和 e2集合中ClassCastException。如果用户试图违反此约束的集合添加一个元素，该 add称将 ClassCastException。 ##两种方法:第一种:在有参构造中直接使用匿名内部类进行comparator接口的实现.在匿名内部类中重写compare(e1, e2)方法第二种:创建一个具体类继承comparator接口.称为comparator接口的子实现类,并重写compare(e1, e2)方法.               
3)ListedHashSet(类):  LinkedHashSet继承自HashSet*元素唯一性(哈希表保证)*(存储和取出一致),链表保证

8)Map集合

1)Java提供了Map<K,V>:键映射到值,一个键对应一个值.(键必须唯一)   
2)功能:*添加功能:V put(K key, V value) :给Map集合添加键值对*删除功能:V remove(Object key):删除指定的键,返回对应的值*判断功能:boolean containsKey(Object key):是否包含指定的键  boolean containsValue(Object value):是否包含指定的值boolean isEmpty():判断是否为空,如果为空,返回true*获取功能:int size():获取Map集合的键值对的个数(元素)
3)遍历方法:常用的遍历:keySet()V get(Object key):通过键获取值Set<K> keySet():获取Map集合中所有的键的集合Set<Map.Entry<K,V>> entrySet():获取所有的键值对对象Map.Entry<K,V>:接口:代表键值对对象K getKey():获取键V getValue():获取值

9)HashMap集合(继承与Map(接口))

1)概念:基于哈希表的 Map接口的实现。这种实现提供了所有可选的Map操作，并允许 null值和 null关键。
2)HashMap的实现原理:HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。（其实所谓Map其实就是保存了两个对象之间的映射关系的一种集合）
3)功能:KeySet():获取所有键值
4)遍历注意事项 自定义对象作为键时,要保证键是不重复的对象，对于该自定义Object类中equals（）和hashCode（）方法

10)TreeMap集合(继承与Map(接口)集合)

1)概念:是一个有序的key-value集合，它是通过红黑树实现的。 
2)功能:public TreeMap():构造方法,默认构造函数。使用该构造函数，TreeMap中的元素按照自然排序进行排列。public TreeMap(Comparator<? super K> comparator):构造一个新的，空的树映射，根据给定的比较器排序。
3)遍历:TreeMap()：空参构造自然排序---->Comparable<T> --->public int compareTo(T t)构造方法：有参构造TreeMap(Comparator<T> comparator)选择器排序---->Comparator<T> --->public int compares(T t1,T t2)

11)Collectinos集合操作工具类

1)概念:针对集合操作的工具类
2)功能:使用比较器排序对List集合中元素进行排序(如果自定义对象,必须要有排序条件)public static <T> void sort(List<T> list, Comparator<? super T> c)public static <T> void sort(List<T> list):自然排序(默认升序)//二分搜索法：前提条件：针对数组/集合有序的！public static <T> int binarySearch(List list, T key):在List集合查询指定key的角标值public static <T>  T max():获取集合中的最大值 public static <T> T min() ：获取集合中的最小值public static void shuffle(List<?> list)：随机置换

12)集合嵌套遍历

1)单列集合嵌套单列集合
/*ArrayList<ArrayList<Student>> :单例集合嵌套单例集合 给当前这个添加元素,遍历出每一个学生的信息
*/public class ArrayListTest {public static void main(String[] args) {//创建大的集合ArrayList<ArrayList<Student>> bigArray = new ArrayList<ArrayList<Student>>() ;//假设三个集合ArrayList<Student>ArrayList<Student> array1 = new ArrayList<Student>() ;Student s1 = new Student("高圆圆", 39) ;Student s2 = new Student("赵又廷", 44) ;//给array1中添加元素array1.add(s1) ;array1.add(s2) ;//将第一个集合中添加到大集合中bigArray.add(array1) ;//第二个集合ArrayList<Student> array2 = new ArrayList<Student>() ;//创建两个学生Student s3 = new Student("刘备", 30) ;Student s4 = new Student("曹操", 33) ;array2.add(s3) ;array2.add(s4) ;bigArray.add(array2) ;//第三个集合ArrayList<Student> array3 = new ArrayList<Student>() ;//创建两个学生Student s5 = new Student("关于", 30) ;Student s6 = new Student("张飞", 33) ;array3.add(s5) ;array3.add(s6) ;bigArray.add(array3);//ArrayList<ArrayList<Student>>//增强for遍历for(ArrayList<Student> array :bigArray) {//ArrayList集合数据类型:Studentfor(Student s :array) {System.out.println(s.getName()+"---"+s.getAge());}}}
}2)双列集合嵌套双列集合:HashMap集合的嵌套遍历第一种嵌套遍历/***HashMap集合嵌套HashMap集合;*HashMap集合作为键时 **/package org.westos.HashMap集合嵌套的遍历;import java.util.HashMap;import java.util.Set;public class Text1 {public static void main(String[] args) {HashMap<HashMap<String,Integer>,String> map = newHashMap<HashMap<String,Integer>,String>();HashMap<String,Integer> hm1 = new HashMap<>();hm1.put("杨过", 23);hm1.put("小龙女", 33);map.put(hm1, "神雕侠侣");HashMap<String,Integer> hm2 = new HashMap<>();hm2.put("张无忌", 23);hm2.put("赵敏", 33);map.put(hm2, "倚天屠龙记");//set集合存储map集合的键Set<HashMap<String,Integer>> set = map.keySet();for(HashMap<String,Integer> hm: set) {System.out.println(map.get(hm));//set集合存储map集合键的键Set<String> setkey = hm.keySet();for(String str:setkey) {int i = hm.get(str);System.out.println("\t"+str+"----"+i);}}}}第二种嵌套遍历/*** HashMap集合嵌套遍历* HashMap集合嵌套HashMap集合* HashMap集合作为值时**/package org.westos.HashMap集合嵌套的遍历;import java.util.HashMap;import java.util.Set;public class Text2 {public static void main(String[] args) {HashMap<String,HashMap<String,Integer>> map = new HashMap<>();HashMap<String,Integer> hm1 = new HashMap<>();hm1.put("杨过", 23);hm1.put("小龙女", 33);map.put("神雕侠侣", hm1);HashMap<String,Integer> hm2 = new HashMap<>();hm2.put("张无忌", 23);hm2.put("赵敏", 33);map.put("倚天屠龙记", hm2);//set集合存储map集合的键Set<String> set = map.keySet();for(String s:set) {HashMap<String,Integer> hm = map.get(s);System.out.println(s);//set集合存储map集合值的键Set<String> setvelunkey = hm.keySet();for(String str:setvelunkey) {int i = hm.get(str);System.out.println("\t"+str+"----"+i);}}}}

13)JDK5新特性(泛型 和 增强for循环)

1)泛型;*JDK5提供的新特性 应用在类上，方法上，接口上*格式： <引用数据类型>*泛型的好处：*将运行时期异常提前到了编译时期*解决了黄色警告线*避免了强制类型转换*提高程序的安全性*泛型的高级通配符:<?>	:表示可以存储任意的Java类型以及Object类型 (保证前后一致)<? extends E>:向下限定,可以存储E类型以及它的子类<? super E>:向上限定,可以存储E类型以及它的父类*泛型在类上,方法上,接口上的定义使用:**将泛型可以定义在类上:public class 类名<T>{}**将泛型可以定义在方法上://将泛型定义在类上,方法的形参和类上泛型一致.//有弊端,每一种不同类型创建调用方法,需要不同类型创建不同类型对象.*public class 类名<T>{public void 方法名(T t){}}//将泛型定义在方法上*public <T> void 方法名(T t){}**将泛型定义在接口上:格式:public interface Inter<T> {void show(T t) ;}第一种情况:子实现类在实现接口的时候已经明确接口的泛型类型了格式: public class InterImpl implements Inter<String> 第二种情况:子实现类实现接口的时候不明确泛型的类型格式: public class InterImpl<T> implements Inter<T>
2)增强for循环:*静态导入，可变参数，自动拆装箱*增强for循环的目的主要是为了替代迭代器，简化书写方式使用场景：集合遍历*使用方式：for(数据类型 变量名 : 集合对象名){输出变量名;}

14)面试题

1)数组和集合的区别:*长度的区别数组：长度固定集合：长度可变*存储类型的区别数组：可以存储基本/引用类型集合：只能存储引用类型*存储元素的区别数组：只能存储同一种元素集合：可以存储不同引用类型元素（类型都是引用类型）
2)Map集合和Collection集合的区别*Collection集合:**是一个单列集合,只能存储一种引用类型**最具体的子实现类:HsahSet和TreeSet*Map集合:**是一个双列集合,能够存储两种引用类型(键和值:是一种键值对存在),理解为夫妻对**HsahMap<K,V>和TreeMap<K,V>
3)Collection和Collections的区别?Collection:是单列集合的顶层接口,是一个集合容器,存储元素!Collections:是一个类,针对集合操作的工具类里面有排序的功能,有二分搜索法的功能,获取最值以及集合随机置换功能!

二.常用类

1)String类及其功能

1)概念:*字符串是常量，而且是不可变的字符序列，一旦被赋值其值不能改变（地址值)*特殊的引用类型，形参的改变不会影响实际参数
2)功能:*构造方法:public String():初始化新创建的 String对象，它代表了一个空字符序列。请注意，使用此构造函数是不必要的，因为字符串是不可变的。 public String(String original):初始化新创建的对象 String所以它代表相同的字符序列的说法；换句话说，新创建的字符串是一个副本的参数字符串。除非 original显式复制是必要的，使用这个构造函数是不必要的因为字符串是不可变的。*判断:	public boolean equals(Object anObject):判断字符串内容与指定的对象中的内容是否都是一致public boolean equalsIgnoreCase(String anotherString):忽略大小写比较public boolean contains(String s):判断是否包含指定的字符串 (是否包含指定的内容:开发中使用居多)public boolean startsWith(String prefix):判断当前字符串是否以指定的内容开头public boolean endsWith(String suffix):判断当前字符串是否指定的内容结尾public boolean isEmpty():判断字符串内容是否为空: 如果为空,返回true public int compareTo(String anotherString):使用当前字符串内容和指定的anotherString按照字典顺序比较!*获取:public char charAt(int index):获取指定索引处的字符public int indexOf(String str):获取指定字符串在大字符串中第一次出现是索引public static String valueOf(int i) : 将int类型转换成字符串public static valueOf():万能方法,可以将任意的类型转换字符串public String concat(String str):字符串拼接public int length():获取字符串的长度public String[] split(String regex):字符串的分割功能 *转换:public byte[] getBytes() :以平台的默认编码集将字符串数据转换成字节数组public char[] toCharArray()  (使用居多):将字符串转换成字符数组public String toLowerCase() :将字符串数据转换成小写public String toUpperCase(): 将字符串数据转换成大写*分割:public String[]  split(String str):按照指定str内容将字符串拆分字符串数组*替换功能以及按照字典顺序比较：public String replace(char target,Char replacement):参数1是原字符，参数2是新字符，新字符替换以前的字符*字符串截取:public String substring(int beginIndex):从指定位置处开始默认截取到末尾public String substring(int beginIndex, int endIndex)：从指定位置处开始截取到指定位置结束(包前不包后)后面这个位置是:endIndex-1处	
3)字符串在程序中的比较:*字符串变量相加：先加空间(产生地址值)，再相加，还需要判断当前相加后的结果在常量是否存在*字符串常量相加：先相加，然后在常量池中寻找是否有，如果存在,直接返回地址值;如果不存在在开空间。

2)StringBuffer类及其功能

1)概念:*是一个线程安全的可变的字符序列！提供了字符串缓冲区（里面存储的都是字符串数据）。形参的改变会影响实际参数的改变.应用多线程，是同步的执行，效率低（从内存角度看）
2)功能:*构造方法：public StringBuffer():默认缓冲区大小,初始容量16个字符 (默认缓冲区大小足够!)public StringBuffer(int capacity):指定固定大小的初始容量,构造一个字符串缓冲区public StringBuffer(String str):构造一个缓冲区大小,容量大小等于字符串长度加上初始容量（16）*获取：public int capacity():获取字符串缓冲区的容量大小!public int length():获取字符串缓冲区中的字符串长度!*添加：#####public StringBuffer append(int/String/boolean...):追加到末尾(末尾追加),可以追加 任何数据,返回值是它本身public StringBuffer insert(int offset,String str):在指定位置处添加指定的字符串(在指定位置处的前面插入数据)*删除:public StringBuffer deleteCharAt(int index):删除指定索引处的字符,返回缓冲区本身 (推荐)public StringBuffer delete(int start,  int end):删除从指定位置开始到指定位置结束的字符(包前不包后)end-1处*替换：public StringBuffer replace（int start,int end,String str）:从start开始到end-1为止，将str替换进去。*反转：###public StringBuffer reverse():将字符串缓冲区字符串进行反转（逆序）*截取：public StringBuffer substring(int start): 从指定位置默认截取到末尾public StringBuffer substring(int start,int end): 从指定位置截取到end-1处结束
3)Stirng和StringBuffer的相互转换*String----->StringBufferStringBuffer(String str)StringBuffer()+append(String str)*StringBuffer --->StringString(StringBuffer buffer)StringBuffer:的功能-->public String toString()

##Stirng和StringBuffer的相互转换的 代码示例

3)Integer类(int类型的包装类类型)

1）MIN_VALUE:获取int类型范围的最小值
2）MAX_VALUE:获取int类型的最大值
3）构造方法：public Integer(int value):将int类型数据构造成Integer类型public Integer(String s):将String类型的数据转换成Integer类型（可能会出现数字转换异常：NumberFormatException）
4)转换方法：int--->Stringpublic static Integer valueOf(int i):public static String toString(int value):int类型转换伟String类型String--->int(使用最多###)public static int  pareseInt(String str):将String类型转换伟int类型
5)JDK5新特性:    自动拆装箱

4)Character类(char类型的包装类类型)

1）构造方法：public Character(char value):
2）成员方法：(判断功能)public static boolean isDigit(char ch):判断当前字符是否为数字字符public static boolean isUpperCase(char ch):判断当前字符是否为大写字母字符public static boolean isLowerCase(char ch):判断当前字符是否为小写字母字符

5)System类

1)包含了一些字段和相关的成员方法字段：in:标准的"输入流"读取内容 (字节输入流)---->InputStreamout:标准的“输出流”打印内容 (字节打印流)---->PrintStreamerr:"错误输出流"  针对内容由红色标记------>PrintStream
2)成员方法:public static void gc() ：手动开启垃圾回收器,jvm会将内存中不用的对象给回收掉实质调用finalize()方法public static long currentTimeMillis():将当前系统时间换算成时间毫秒值;单独使用一般没有意义;public static void arraycopy(Object src,int srcPos,Object dest,int destPos,  int length)从指定源数组中的某个位置开始到指定目标数组的某个位置结束,指定多个长度参数1:源数组对象参数2:源数组中的某个索引值参数3:目标数组对象参数4:目标数组对象的某个索引值参数5:复制的长度/*代码示例int[] arr1 = {11,22,33,44,55} ;int[] arr2 = {5,6,7,8,9} ;System.out.println(Arrays.toString(arr1));//[11, 22, 33, 44, 55]System.out.println(Arrays.toString(arr2));//[5, 6, 7, 8, 9]System.out.println("--------------------------------");//arraycopy(Object src,int srcPos,Object dest,int destPos,  int length)System.arraycopy(arr1, 3, arr2, 3, 2);System.out.println(Arrays.toString(arr1));//[11, 22, 33, 44, 55]System.out.println(Arrays.toString(arr2));//[5, 6, 7, 44, 55]*/

6)Date类

1）日期类：特定的瞬间，精确到毫秒
2）构造方法：public Date():空参构造,创建日期对象
3）成员方法：public long getTime() :将Date--->long 类型时间毫秒值(自 1970 年 1 月 1 日 00:00:00 GMT )long类型应用场景:定义时间毫米值
4）Date日期格式和日期文本格式转换 ###年：yyyy月：MM日：dd小时：HH(24小时制)  hh(12小时制)                         分钟：mm秒钟：ss    毫秒: sss                                     Date---->String:格式化/*//1)创建日期Date对象Date date = new Date() ;//2)创建中间的桥梁:创建SimpleDateFormat对象(日期和文本的相互转换)//指定一个模式:SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;//3)格式化:  public final String format(Date date)String str = sdf.format(date) ;System.out.println(str);//获得当前日期:2020-08-05*/String(文本格式)-->Date:解析/*//将文本格式---->Date日期格式:解析//定义文本日期格式String dataStr = "2018-05-12" ;//创建SimpleDateFormat//此时里面注意://模式必须要日期文本格式的模式要匹配SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd") ;// public Date parse(String source) throws ParseException:解析//如果解析出问题了,JVM将异常的信息打印在控制台Date date2 = sdf2.parse(dataStr) ;System.out.println(date2);//Sat May 12 00:00:00 CST 2018*/

7)Calendar类（日历类)（抽象类）

1)Calendar:日历类:是一个抽象类,提供了获取年,月,日,时分秒等等相关日历时间!
2)不能实例化，使用里面的一个静态的功能*public static Calendar getInstance():利用这个静态来进行Calendar实例化*格式: Calendar c = Calendar.getInstance();3)获取日历：public int get(int field):获取日历字段的内容!//获取年份//public static final int YEARint year = c.get(Calendar.YEAR) ;//获取月份//public static final int MONTH:月份字段(角标从0-11：表示整个12个月)int month = c.get(Calendar.MONTH) ;//获取月中日期://public static final int DATE：字段int date = c.get(Calendar.DATE) ;
3)成员方法：public abstract void add(int field,int amount):给指定的字段添加或减去时间偏移量！参数1：常量字段：YEAR，MONTH，DATE（DAY_OF_MONTH）参数2：就是时间偏移量public final void set(int year，int month,int date)：设置指定的年月日

8)Random类

1）随机数生成器
2)构造方法：public Random():产生一个随机数生产器 (使用居多)public Random(long seed):创建随机数生成器的同时,给固定时间值它产生的随机数永远是固定的
3）成员方法:public int nextInt() :取值范围是int类型的范围(不用)public int nextInt(int n):可以获取0-n之间的随机数,取不到n :[0,n)
4)获取随机数的两中办法：Math里面random方法：Math.random();//[0.0,1.0)Random类 ：nextInt(int n) 用法: Random()空参构造+nextInt(int n):获取随机数                   

9)Math类

1)数学运算工具类
2)成员方法（静态）：public static int 	 abs   (int a):绝对值public static double ceil  (double a):向上取整public static double floor (double a):向下取整											public static int	 max   (int a,  int b):取两个数据的较大值public static int	 min   (int a,  int b):取两个数据的较小值public static double pow   (double a, double b):a的b次幂public static double random():0.0-1.0之间的随机数(不包含1.0) (使用居多)public static long 	 round (double a):四舍五入public static double sqrt  (double a):对一个正整数开平方根
3)使用方法：Math.方法名（参数列表）；

10)BigDeciaml类 和 Arrays:数组的工具类

1)BigDeciaml类:*针对浮点类型运算的时候进行精确计算*构造方法:public BigDecimal(String val)*成员方法:public BigDecimal add(BigDecimal augend)public BigDecimal subtract(BigDecimal subtrahend): -减法public BigDecimal multiply(BigDecimal multiplicand) *:乘法public BigDecimal divide(BigDecimal divisor):/ 除法
2) Arrays:数组的工具类public static String toString(int[] arr): 将数组转换为字符串，按格式输出public static void sort(short[] a):将指定的数组排序为上升的数值顺序。 

11)面试题

1)String,StringBuffer,StringBuilder的区别?*从概念看：String：字符串是常量，而且是不可变的字符序列，一旦被赋值其值不能改变（地址值）StringBuffer:是可变的字符序列，字符串缓冲区中可以无限加入内容StringBuilder：和StringBuffer具有兼容的API*从形式参数看：String：特殊的引用类型，形参的改变不会影响实际参数StringBuffer:  形参的改变会影响实际参数的改变StringBuilder：形参的改变会影响实际参数的改变*从线程安全看:String：StringBuffer:  线程安全类，应用多线程，是同步的执行，效率低（从内存角度看）StringBuilder：线程不安全类，应用于单线程，不同步，效率高（从内存角度看）
2)StringBuffer和数组的区别?*从概念看:数组：是一种容器，只能存储同一种类型数据，既可以存储基本类型，也可以存储引用类型StringBuffer:是一种容器，里面存储字符串内容*从存储数据类型看:数组:只能存储同一种类型的元素,不仅仅可以存储基本类型,还可以存储引用类型(但是元素的类型一致)StringBuffer:构造一个字符串缓冲区,缓冲区中的内容都是以字符串形式体现的*从长度看: 		数组:获取数组的长度:length属性!StringBuffer:获取字符串长度:length()
3)Integer类的面试题:	/*//==:连接的是两个引用类型:比较的是地址是否相同!//Integer类重写了Object类中的equals方法():比较的内容是否相同Integer i1 = new Integer(127) ;Integer i2 = new Integer(127) ;System.out.println(i1==i2);//falseSystem.out.println(i1.equals(i2));//trueSystem.out.println("------------------------");Integer i3 = new Integer(128) ;Integer i4 = new Integer(128) ;System.out.println(i3== i4);//falseSystem.out.println(i3.equals(i4));//trueSystem.out.println("-------------------------");Integer i5 = 127 ;Integer i6 = 127 ;System.out.println(i5==i6);//true (从IntegerCache:缓存区中取元素)System.out.println(i5.equals(i6));//trueSystem.out.println("-------------------------");Integer i7 = 128 ;  //new Integer(128)Integer i8 = 128 ;  //new Integer(128)System.out.println(i7==i8);//falseSystem.out.println(i7.equals(i8));//true*/