java集合的使用
1.集合分为两类,java.util.Colleciotn(直接存储对象应用)java.util.Map(以键值对的形式存储)
2.数组可以理解为一个集合。集合实际上为一个容器,用于存储其他类型的数据。集合同时也是一个对象。
3.集合不能存储基本数据类型,只能够存储引用数据类型。存储基本数据类型是会自动装箱,int转换为Integer等。
4.集合中存储的是对象的引用地址。
5.java中不同的集合底层对应不同的数据结构(数组,双向链表,二叉树,哈希表)
一、Collection继承结构(常用集合)
(一)Collection
public interface Collection<E> extends Iterable<E>
Iterable类中有一个iterator()方法,返回一个Iterator对象(常用方法:hasNext(),next())
Collection的所有子类均可以调用iterator()方法,,返回一个Iterator对象,用于迭代集合中的元素。同时表明所有Collection集合均可迭代
(二)List
public interface List<E> extends Colleciton<E>
特点:
1.存储元素有序可重复,存储顺序与迭代顺序一致。
2.存储元素有下标,从0开始递增。
(三)Set
public interface Set<E> extends Colleciton<E>
特点:
1.存储元素无序不可重复,存储顺序与迭代顺序不一定一致。
2.存储元素无下标。
3.向Set中存数据实际是存入了Map中的key部分
二、Map继承结构(常用集合)
(一)Map
public interface Map<K,V>
特点:
1.Map与Collection无关系
2.Map集合通过key与value(键值对)的形式进行存储对象引用,key与value均可以是对象引用地址。
三、Collection常用方法
Collection若不指定泛型,则可以存储任意Object的子类对象的引用
1.boolean add(Object e) 向集合中添加元素
2.int size() 获取集合大小
3.void clear() 清空元素
4.boolean remove(Object o) 删除某个元素
5.boolean isEmpty(Object o) 判断集合是否为空 底层判断size是否为0
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest01 {
public static void main(String[] args) {
Collection collection = new ArrayList();//多态使用,Collection为接口,不能直接创建对象
//add()方法 添加元素
collection.add(100);//自动装箱,实际上放入了一个Integer
collection.add(0.99);//自动装箱,实际放入了一个Double
collection.add(new Object());//放入一个Object对象
//size()方法 获取集合大小
int size = collection.size();
System.out.println(size); //3
//remove(Object o) 删除某个元素
collection.remove(100);
System.out.println(collection.size()); //2
//clear()方法 清空集合
collection.clear();
System.out.println(collection.size());//0
//isEmpty()方法 判断集合是否为空
System.out.println(collection.isEmpty());//true
}
}
6.boolean contains(Object o) 判断集合中是否存在某个数据
7.Object[] toArray() 将集合转换为一个数组
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest01 {
public static void main(String[] args) {
Collection collection = new ArrayList();//多态使用,Collection为接口,不能直接创建对象
collection.add("张三");
collection.add("李四");
collection.add("王五");
//boolean contains(Object o) 判断集合中是否存在某个数据
boolean flag1 = collection.contains("张三");
boolean flag2 = collection.contains("赵六");
System.out.println("flag1: "+flag1+" flag2: "+flag2);//flag1: true flag2: false
//Object[] toArray() 将集合转换为一个数组
Object[] objects = collection.toArray();
for(Object o:objects){
System.out.println(o);//张三 李四 王五
}
}
}
8.Iterator<E> iterator()
(1)boolean hasNext() 如果集合可以迭代,返回True
(2)Object next() 返回集合下一个迭代的元素
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionTest02 {
public static void main(String[] args) {
Collection collection = new ArrayList();//多态使用,Collection为接口,不能直接创建对象
collection.add(100);
collection.add(3.14);
collection.add("张三");
collection.add(new Object());
//迭代器迭代对于Collection集合通用
//第一步:获取集合迭代器对象
Iterator iterator = collection.iterator();
//第二步:通过迭代器进行迭代遍历
//boolean hasNext() 如果集合可以迭代,返回True
//Object next() 返回集合下一个迭代的元素
while (iterator.hasNext()){
Object o = iterator.next();
System.out.println(o);//100 3.14 张三 java.lang.Object@1b6d3586
}
}
}
三、List特有方法
(一)常用类
ArrayList
底层为数组,非线程安全。
由于数组中元素在内存空间中地址连续,因此增删元素会导致大量元素位移,效率较低。但是可以通过下标查找元素,效率较高
LinkedList
底层为双向链表。
由于链表中元素在内存空间中地址不连续,因此增删元素不会导致大量元素位移,效率较高。但是由于不能通过数学表达式计算指定元素的地址,只能从头开始迭代查找元素,效率较低。
Vector
底层为数组,与ArrayList不同的是Vector为线程安全的
(二)构造方法
import java.util.*;
public class ListTest02 {
public static void main(String[] args) {
List list01 = new ArrayList();//无参构造,默认初始化容量10
List list02 = new ArrayList(100);//有参构造,指定初始化容量100
Collection collection = new HashSet();
collection.add(1);
collection.add(2);
collection.add(3);
collection.add(4);
List list03 = new ArrayList(collection);//有参构造,将其他Collectoin集合转换为List集合
}
}
(三)成员方法
1.void add(int index ,E element) 向指定位置插入元素
2.E get(int index) 根据下标获取元素
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListTest01 {
public static void main(String[] args) {
List list = new ArrayList();//使用List特有方法,不能用Colleciton声明对象
list.add("A");//默认向尾部插入元素
list.add("B");
list.add("C");
list.add("D");
list.add("E");
//void add(int index ,E element) 向指定位置插入元素
list.add(1,"F");
Iterator iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());//A F B C D E
}
//E get(int index) 根据下标获取元素
Object o = list.get(1);
System.out.println(o); //F
//通过下标遍历列表
for(int i = 0;i< list.size();i++){
System.out.println(list.get(i));A F B C D E
}
//增强for遍历
for (Object s:list){
System.out.println(s); //A F B C D E
}
//
}
}
3.int indexOf(Object o) 获取指定对象第一次出现时的索引
4.int lastIndexOf(Object o) 获取指定对象最后一次出现时的索引
5.E remove(int index) 删除指定位置的元素 并且返回删除的元素
6.E set(int index,E element) 修改指定位置的元素 并且返回被修改之前的元素
import java.util.ArrayList;
import java.util.List;
public class ListTest01 {
public static void main(String[] args) {
List list = new ArrayList();//使用List特有方法,不能用Colleciton声明对象
list.add("A");//默认向尾部插入元素
list.add("B");
list.add("C");
list.add("D");
list.add("E");
list.add("A");
list.add("E");
//int indexOf(Object o) 获取指定对象第一次出现时的索引
//int lastIndexOf(Object o) 获取指定对象最后一次出现时的索引
//初始List A B C D E A E
System.out.println(list.indexOf("A")); //0
System.out.println(list.lastIndexOf("A")); //5
//E set(int index,E element) 修改指定位置的元素
Object b = list.set(0, "B");
System.out.println(b);//A
for(Object o :list){
System.out.println(o);//B B C D E A E
}
//E remove(int index) 删除指定位置的元素
Object remove = list.remove(0);
System.out.println(remove);//B
for(Object o :list){
System.out.println(o);//B C D E A E
}
}
}
四、Set详解(常用类)
(一)常用类
HashSet(实际使用过成功方法也会自动排序 T^T 可以研究下底层代码)
TreeSet(SortedSet子类)
SortedSet会自动将元素进行排序
对于自定义的类,可以有两种方式
一是:需要实现java.lang.Comparable接口
二是:实现java.lang.Comparator接口,作为一个参数在构造时候进行传递(可使用匿名内部类)
import java.util.HashSet;
import java.util.Set;
public class SetTest01 {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
set.add("A");
set.add("B");
set.add("E");
set.add("D");
set.add("H");
set.add("Z");
set.add("E");
set.add("B");
//传入元素: A B E D H Z E B
for(String s : set){
System.out.println(s);//A B D E H Z 去重排序
}
}
}
五、Collection常用方法
(一)常用方法
1.V put(K key, V value) 向Map集合中添加键值对
2.int size() 获取Map的大小
3.V get(Object key) 通过key获取value
4.boolean containsKey(Object key) 判断Map是否包括某个key,底层调用equals方法,若自定义类型,需要重写equals方法
5.boolean containsValue(Object value) 判断Map是否包括某个key,底层调用equals方法,若自定义类型,需要重写equals方法
6.void clear() 清空Map集合
7.boolean isEmpty() 判断集合是否为空
import java.util.HashMap;
import java.util.Map;
public class MapTest01 {
public static void main(String[] args) {
//创建Map集合对象
Map<Integer,String> map = new HashMap<Integer, String>();
//调用put方法向Map集合中增加元素
//V put(K key, V value) 向Map集合中添加键值对
map.put(1, "张三");
map.put(2,"李四");
map.put(3,"王五");
map.put(4,"赵六");
//int size() 获取Map的大小
int size = map.size();
System.out.println(size);//4
//V get(Object key) 通过key获取value
String string1 = map.get(1);//Map中有key值为1的元素
System.out.println(string1);//张三
String string2 = map.get(5);//Map中无key值为null的元素
System.out.println(string2);//null
//boolean containsKey(Object key) 判断Map是否包括某个key
//boolean containsValue(Object value) 判断Map是否包括某个key
//底层调用equals方法,若自定义类型,需要重写equals方法
System.out.println(map.containsKey(1));//true
System.out.println(map.containsKey(5));//false
System.out.println(map.containsValue("张三"));//true
System.out.println(map.containsValue("小明"));//false
//void clear() 清空Map集合
map.clear();
System.out.println(map.size());//0
//boolean isEmpty() 判断集合是否为空
System.out.println(map.isEmpty());//true
}
}
8. Collection<V> values() 获取Map的所有value并返回一个collection
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class MapTest01 {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "张三");
map.put(2,"李四");
map.put(3,"王五");
map.put(4,"赵六");
//Collection<V> values() 获取Map的所有value并返回一个collection
Collection<String> values = map.values();
for(String s : values){
System.out.println(s);//张三 李四 王五 赵六
}
}
}
(二)遍历Map集合
1.获取所有的key,通过遍历key,遍历value
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapTest01 {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "张三");
map.put(2,"李四");
map.put(3,"王五");
map.put(4,"赵六");
//Set<K> keySet() 获取Map的所有Key并返回一个set
Set<Integer> integers = map.keySet();
for(Integer i :integers){
System.out.println(i+" "+map.get(i));
}
}
}
2.调用Set<Map.Entry<K,V>> entrySet() 将Map集合转换为一个Set集合,进行遍历
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapTest01 {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "张三");
map.put(2,"李四");
map.put(3,"王五");
map.put(4,"赵六");
//Set<Map.Entry<K,V>> entrySet() 将Map集合转换为一个Set集合
Set<Map.Entry<Integer, String>> entries = map.entrySet();
for(Map.Entry<Integer,String> item :entries){
System.out.println(item.getKey() +" "+item.getValue()+" 就是 "+item);
}
}
}
六、Map常用类
(一)HashMap
底层实现为哈希表
(二)HashTable
底层实现为哈希表,线程安全的
(三)Properties
线程安全的,继承与Hashtable,线程安全的,key与value的值必须为字符串
import java.util.Properties;
public class PropertiesTest {
public static void main(String[] args) {
//String getProperty(String key) 通过key获取value
//Object setProperty(String key, String value) 向集合中放入键值对
Properties properties = new Properties();
properties.setProperty("url","jdbc:mysql:/localhost:3306/mydatabase");
properties.setProperty("name","root");
properties.setProperty("password","12345");
System.out.println(properties.getProperty("name"));
}
}
(四)TreeMap(SortedMap子类)
底层实现为二叉树,key值会自动排序,底层调用comparedto方法
七、Collections工具类
1.Collections.synchronizedCollection(Collection) 可以将非线程安全的转换为线程安全的
Collections.synchronizedMap(Map) 可以将非线程安全的转换为线程安全的
2.Collections.sort(List c) 对集合进行排序