Java集合基本知识总结-常用类基本知识总结
程序员文章站
2022-10-03 14:51:52
一.集合(Colleection)1)集合中的继承关系图2)Collection集合 (集合的最大接口)1）JDK不提供此接口的任何直接实现，他提供更具的子接口（子实现类）实现2）基本功能:*添加：boolean add(Object e):添加任意的引用类型元素*删除： boolean remove(Object e):删除指定的元素 void clear():清空集合中的所有元素 *判断： boolean contains(...
一.集合(Colleection)
1)集合中的继承关系图
2)Collection集合 (集合的最大接口)
1）JDK不提供此接口的任何直接实现，他提供更具的子接口（子实现类）实现
2）基本功能:
*添加：
boolean add(Object e):添加任意的引用类型元素
*删除：
boolean remove(Object e):删除指定的元素
void clear():清空集合中的所有元素
*判断：
boolean contains(Object o):判断是否包含指定的元素 包含就返回true，否则返回false
boolean 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)方法相结合遍历:普通for
for(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接口。此外，所有这些元素必须相互比较：
e1.compareTo(e2)不得把任何元素 e1和 e2集合中的ClassCastException。如果
用户试图违反此约束集合添加一个元素（例如，用户尝试一系列的元素添加一个字符
串，整数单元）的 add称将 ClassCastException。
注意:
在自定义的类中需要手动实现继承Comparable接口,并且手动重写compareTo()方法.
在非自定义的类中已经继承了Comparable接口,已经重写了compareTo()方法
**选择器排序:
使用有参构造方法:
public TreeSet(Comparator<? super E> comparator):构造一个新的、空的树集，
根据指定的比较器进行排序。所有的元素插入到集合必须相互比较由指定的比较器
comparator.compare(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集合数据类型:Student
for(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 = new
HashMap<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----->StringBuffer
StringBuffer(String str)
StringBuffer()+append(String str)
*StringBuffer --->String
String(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--->String
public 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:标准的"输入流"读取内容 (字节输入流)---->InputStream
out:标准的“输出流”打印内容 (字节打印流)---->PrintStream
err:"错误输出流" 针对内容由红色标记------>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 YEAR
int 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);//false
System.out.println(i1.equals(i2));//true
System.out.println("------------------------");
Integer i3 = new Integer(128) ;
Integer i4 = new Integer(128) ;
System.out.println(i3== i4);//false
System.out.println(i3.equals(i4));//true
System.out.println("-------------------------");
Integer i5 = 127 ;
Integer i6 = 127 ;
System.out.println(i5==i6);//true (从IntegerCache:缓存区中取元素)
System.out.println(i5.equals(i6));//true
System.out.println("-------------------------");
Integer i7 = 128 ; //new Integer(128)
Integer i8 = 128 ; //new Integer(128)
System.out.println(i7==i8);//false
System.out.println(i7.equals(i8));//true
*/
本文地址：https://blog.csdn.net/liming11112/article/details/107897416
下一篇： 胡萝卜的皮要不要去掉？怎么保存胡萝卜？