JAVA 基础学习之集合

Iterable

接口

 

实现这个接口允许对象成为 "foreach" 语句的目标。

所有的容器对象，只要实现了 Iterable ，遍历容器中元素的时候都可以使用 foreach 循环

Collection

Collection 有两个子接口： List 和 Set

 

Collection 表示一组对象 , 里面的每一个对象称为元素。

一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的

 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class CollectionTest {
public static void main(String[] args) {
//创建一个Collection对象
Collection collection = new ArrayList();
//(1)add 添加元素
collection.add("java");
collection.add("mysql");
collection.add("spring");collection.add("php");
//(2)addAll 将指定 collection 中的所有元素都添加到此 collection 中
Collection all = new ArrayList();
all.add("mysql");
all.add("spring");
// collection.addAll(all);
// System.out.println(collection);
//(3) clear()
//collection.clear();
//System.out.println(collection);
//(4) contains(Object element) 判断是否包含某个元素
System.out.println(collection.contains("mysql"));
//(5)containsAll 此 collection 包含指定 collection 中的所有元素
System.out.println(collection.containsAll(all));
//(6)isEmpty 判断容器是否为空 是否有元素
System.out.println(collection.isEmpty());
//(7)remove(Object element) 删除元素
collection.remove("mysql");
System.out.println(collection);
//(8) size 容器的元素个数
System.out.println(collection.size());
//(9) toArray 转为数组
Object[] arr = collection.toArray();
System.out.println(Arrays.toString(arr));
}
}

 

Collection元素的遍历

 

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionIterator {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("java");
collection.add("mysql");

List

有序的 collection ，对列表中每个元素的插入位置进行精确地控制

先插入的再前面，后插入的在后面【不是按照大小顺序，是按照插入的先后顺序】

用户可以根据元素的整数索引（在列表中的位置）访问元素

允许有重复的元素

collection.add("spring");
collection.add("php");
//使用迭代器遍历Collection中的元素
Iterator iterator = collection.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
package com.qjzx._03_list;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
public static void main(String[] args) {
List list = new ArrayList();
list.add("java");
list.add("php");
list.add("mysql");
System.out.println(list);
//(1)add(int index,Objec element)
list.add(2,"javascript");
System.out.println(list);
//(2)Object get(int index) 根据索引获取
System.out.println(list.get(1));
//(3)indexOf lastIndexOf -1表示集合中不包含这个元素
System.out.println(list.indexOf("abc"));
System.out.println(list.lastIndexOf("abc"));
//(4)Object remove(int index) 删除并返回元素
System.out.println(list.remove(3));//mysql
System.out.println(list);//[java, php, javascript]
//(5)Object set(int index,Object ele) 用新元素替换指定位置的旧元素，并将旧元素
返回
System.out.println(list.set(1, "c++"));//php
System.out.println(list);//[java, c++, javascript]//(6)subList(int begin,int end) 包含begin，不包含end进行元素的截取，返回新的集
合对象
List newList = list.subList(0, 2);
System.out.println(list);
System.out.println(newList);
}
}

 

List的遍历

 

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorTest {
public static void main(String[] args) {
List list = new ArrayList();
list.add("java");
list.add("c");
list.add("c++");
list.add("c#");
list.add("python");
list.add("go");
//第一种
Iterator iterator = list.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("=================完美分割线2==================");
//第二种 1、可以根据索引获取元素 2、有size表示元素个数
for(int i = 0; i <= list.size()-1; i++) {
System.out.println(list.get(i));
}
System.out.println("=================完美分割线3==================");
//第三种
for(Object ele : list) {
System.out.println(ele);
}System.out.println("=================完美分割线4==================");
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()) {
System.out.println(listIterator.next());
}
System.out.println("=================完美分割线5==================");
//一个新的迭代器对象箭头指针在第一个元素前面
//ListIterator listIterator1 = list.listIterator();
while(listIterator.hasPrevious()) {
System.out.println(listIterator.previous());
}
/*
*
* Iterator和ListIterator的区别：
* 1、Iterator只能正向迭代，ListIterator双向都可以迭代
* 2、Iterator在迭代的时候只能调用迭代器的remove方法删除迭代出的元素
* 3、ListIterator在迭代的过程中可以进行增删改操作
*
*
* 
*
* */
}
}

 

Map

 

也是一种容器

API文档描述：将键映射到值的对象。一个映射(一个Map对象)不能包含重复的键；每个键最多 只能映射到一个值 Collection接口下

键(key)   ： 本质就是一个数据

值(value)   ： 本质也是一个数据

键值对： 就是一对（和两个是有区别的），一对一般是有某种关系

映射 ： 上面说的一个映射就看成是一个Map对象 key对应value是一种映射关系

|--   TreeMap    ： 判断重复的规则和TreeSet一样

 TreeMap中的键（key）要么是具有自然排序能力；或者TreeMap中提供一个比较器

 如果key是自然或者定制排序，返回值是0表示，key是重复的，如果是正数，则按照key的升序排序，否则是降序

|--   HashMap   ： key判断键是否重复和HashSet判断重复一样:1. hashCode  2.equals()

|--   HashTable   ： 就是一个线程安全的HashMap

|--   LinkedHashMap： 就是一个内部维护了一个链表的HashMap，可以保证存入和取出顺序

|--  Properties：特殊的HashTable，只不过key-value都是String类型，一般用来做

Map的遍历方式

1. 如果只是获取所有一个值，推荐使用  values()方法

2. 如果只是获取所有的key，推荐使用keySet()方法

3. 如果获取所有的key-value，就使用entrySet()，不要用先通过keySet()获取key，再用get()获取具体的value，这样会导致二次查询，效率低下

Map m = new HashMap();
m.put("小明", 90);
m.put("小马", 60);
m.put("小郭", 60);
Set keys = m.keySet();
for (Object k : keys) {
	System.out.println(k+"<---->"+m.get(k));
}

Map m = new HashMap();
m.put("小明", 90);
m.put("小马", 60);
m.put("小郭", 60);
Set entrys = m.entrySet();
for (Object en : entrys) {
	// 需要把en强制转成 Entry类型
	Entry e = (Entry)en;
	System.out.println(e.getKey()+"--"+e.getValue());
}

Map的使用选择

 

一般情况下我们选用HashMap，因为HashMap的键值对在取出时是随机的，其依据键的hashCode和键的equals方法存取数据，具有很快的访问速度，所以在Map中插入、删除及索引元素时其是效率最高的实现。而TreeMap的键值对在取出时是排过序的，所以效率会低点

1、Map中，HashMap具有超高的访问速度，如果我们只是在Map 中插入、删除和定位元素，而无关线程安全或者同步问题，HashMap 是最好的选择。

2、如果考虑线程安全或者写入速度的话，可以使用HashTable，JDK8后建议使用ConcurrentHashMap替代HashTable,既能获取超高的访问速度，又能保证线程安全

3、如果想按怎么存的顺序怎么取，比如队列形式，排队，那么使用LinkedHashMap

4、如果需要让Map按照key进行升序或者降序排序，那就用TreeMap