List 特点：有序（存取一致），可重复的
实现类：
1.ArrayList:数组实现，查找快，增删比较慢，线程不安全的（Java1.5以后出现）
2.LinkedList:链表实现，增删快，查找比较慢
3.Vector:数组实现的，线程安全的，效率比较低（1.5以前的）
Set 特点：无序（存取不一致），不可重复的
实现类：
1.HashSet:Hash表实现的
2.LinkedHashSet:唯一一个可以使Set集合有序的实现类
3.TreeSet:用于集合中数据的排序
Map 特点：存的是键值对,键不能重复，值可以重复
实现类：
1.HashMap:Hash表实现的（1.5以后的），线程不安全的,允许key或者value为null
2.LinkedHashMap:
3.TreeMap:
4.Hashtable:线程安全的（1.5以前的）不允许null的key或value
collection和collections
collection是接口
collection是类（针对上述接口的操作方法）
ListDemo.java
package list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListDemo {
/*
* 使用迭代器遍历list集合,如果集合中有
* 元素a,那么添加一个元素aa
*/
public static void main(String[] args) {
//1.使用for循环遍历集合
// demo1();
//2.使用foreach语句遍历集合
/**
* foreach并不是一个关键字，习惯上将这种特殊的for语句格式称之为“foreach”语句。
* 从英文字面意思理解foreach也就是“for 每一个”的意思。实际上也就是这个意思。
*/
// demo2();
//3.使用迭代器遍历集合
// demo3();
//ListIterator有add方法，可以向List中添加对象，而Iterator不能
// demo4();
}
/**
* 1.使用for循环遍历集合
*/
private static void demo1() {
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
/**
* 2.使用foreach语句遍历集合
*/
private static void demo2() {
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
for (String str : list) {
System.out.println(str);
}
}
/**
* 3.使用迭代器遍历集合
*/
private static void demo3() {
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Iterator<String> it = list.iterator();
while(it.hasNext()) {
String str = it.next();
System.out.println(str);
}
}
private static void demo4() {
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
/*
* ListIterator有add方法，可以向List中添加对象，而Iterator不能。
*/
ListIterator<String> it1 = list.listIterator();
System.out.println(list);
while(it1.hasNext()) {
String str = it1.next();
System.out.println("str:"+str);
if("a".equals(str)) {
it1.add("aa");
}
}
System.out.println(list);
}
}
Person.java
package list;
public class Person implements Comparable<Person>{
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name="+name +",age=" + age +"]";
}
/*
* 该方法的返回值决定了集合将如何存储元素
* 返回0时，只存一个元素
* 返回正数时,集合正序存储
* 返回负数时，集合倒序存储
*/
public int compareTo(Person o) {
return -1;
}
}
SetMap.java
package list;
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
/*
* map的遍历方式
* 1.遍历所有的key
* 2.遍历所有的value
* 2.遍历所有的键值对
*/
//遍历所有的key keySet()
// demo1();
//遍历所有的value values()
// demo2();
//遍历所有键值对 entrySet()
// Map<String,Integer> map = new HashMap<>();
Map<String,Integer> map = new Hashtable<>();
/*
* HashMap允许key或者value为null
* Hashtable不允许null的key或者value
*/
map.put("tom", 13);
map.put("jerry", 18);
map.put("Jhon", 23);
Set<Entry<String,Integer>> set = map.entrySet();
for(Entry<String,Integer> entry : set) {
System.out.println(entry.getKey()+","+entry.getValue());
}
}
private static void demo2() {
Map<String,Integer> map = new HashMap<>();
map.put("tom", 10);
map.put("jerry", 18);
map.put("Jhon", 23);
int a = map.get("tom");
System.out.println(a);
Collection<Integer> val = map.values();
System.out.println(val);
}
private static void demo1() {
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("tom", 10);
map.put("jerry", 18);
map.put("Jhon", 23);
Set<String> set = map.keySet();
System.out.println(set);
}
}
MapDemo.java
package list;
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
/*
* map的遍历方式
* 1.遍历所有的key
* 2.遍历所有的value
* 2.遍历所有的键值对
*/
//遍历所有的key keySet()
// demo1();
//遍历所有的value values()
// demo2();
//遍历所有键值对 entrySet()
// Map<String,Integer> map = new HashMap<>();
Map<String,Integer> map = new Hashtable<>();
/*
* HashMap允许key或者value为null
* Hashtable不允许null的key或者value
*/
map.put("tom", 13);
map.put("jerry", 18);
map.put("Jhon", 23);
Set<Entry<String,Integer>> set = map.entrySet();
for(Entry<String,Integer> entry : set) {
System.out.println(entry.getKey()+","+entry.getValue());
}
}
private static void demo2() {
Map<String,Integer> map = new HashMap<>();
map.put("tom", 10);
map.put("jerry", 18);
map.put("Jhon", 23);
int a = map.get("tom");
System.out.println(a);
Collection<Integer> val = map.values();
System.out.println(val);
}
private static void demo1() {
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("tom", 10);
map.put("jerry", 18);
map.put("Jhon", 23);
Set<String> set = map.keySet();
System.out.println(set);
}
}
