JAVA 集合总结+DEMO

/*Collection 接口中有两个常用的子接口：List（列表），Set（集）。

*List：元素存取是有序的，可存放重复元素。
                 ArrayList:底层为数组结构。查询速度快。增删稍慢。线程不同步。
                 LinkedList:底层为链表结构。增删速度快，查询稍慢。线程不同步。有更丰富的头尾操作。
                 Vector:底层为数组结构。线程同步。被ArrayList替代了。因为效率低。

*Set：元素存取是无序的，不可以存放重复元素。
                HashSet：HashSet:数据结构是Hash表，线程是非同步的。
    保证元素的唯一性原理：判断元素的HashCode是否相同，如果相同，还会继续判断元素的equals方法，是否为true。

                TreeSet：数据结构为二叉树，线程不同步。

  可以对Set集合中的元素进行排序

                                  实现Comparable接口，重写compareTo(Object obj)方法或

  实现Comparator接口，重写compare(Object o1,Object o2)方法

*Map：存储键值对，键不可以重复，值可以重复。
                取出map集合元素的两种方式方法keySet()和entrySet()。
                HashMap：数据结构为哈希表，允许使用 null 值和 null 键，线程不同步。
                Hashtable：数据结构为哈希表，不可以存入null键null值，线程同步。
                TreeMap：数据结构为二叉树。线程不同步。
                              用于给map集合中的键进行排序（排序方法和TreeSet一样，实现comparable 或 comparator 接口即可）。

* 注：其实Set底层就是使用了Map集合

*/

public class JavaBase_Collection {

/*
* List:元素可以重复,有序 
* ArrayList:结构（数组列表）,底层代码操作的就是数组。 非实现 synchronized 线程同步，是非线程安全的。
* Vector：实现了 synchronized 线程同步，是线程安全的 。
* LinkedList： 结构（链表结构）有更丰富的头尾操作。
*/


@Test
public void ArrayListTest() {
List<String> list = new ArrayList<String>();
list.add(0, "aa");
list.add(0, "bb");
list.add("cc");
System.out.println("重复下标插入会当前下标的元素往后面移动，所以现在的元素大小为：" + list.size());


// 遍历方式
System.out.println(" for 下标循环");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i));
}
System.out.println("\n forEach 遍历");
for (String str : list) {
System.out.print(str);
}
System.out.println("\n Itorator 迭代器遍历");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.print(it.next());
}


// contains 只判断是否存在指定的值，
// 如果一个拿一个相同的对象来进行比较， 则需要在改对象类内重写 equals
// 方法(可选择类中的某个属性作为重写equals的条件，比如ID)
person p = new person();
p.setAge(20);
p.setName("afen");
person p1 = new person();
p1.setAge(20);
p1.setName("afen");
List<person> lp = new ArrayList<person>();
lp.add(p);
System.out.println("\n" + lp.contains(p1));


// remove 的返回值就是被移除的对象
String str = list.remove(0);
System.out.println("我是被 remove 掉的对象：" + str);
}


/*
* Vector 底层也是数组的操作大部分功能和 ArrayList 一样； 区别 Vector 底层代码实现了 synchronized
* 所以是线程安全的，而 ArrayList 则是非线程安全的。
*/
@Test
public void vactorTest() {
Vector<String> v = new Vector<String>();
v.add("aa");
v.add("bb");
// 遍历方式除了for,forEach,Iterator 之外，还有一种老版本的方式
Enumeration<String> e = v.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
}


/*
* LinkedList 和  ArrayList 使用基本类似 LinkedList 有更丰富的头尾操作 
* 底层数据结构是 链表结构
*/
@Test
public void LinkedListTest() {
LinkedList<String> linkList = new LinkedList<String>();
linkList.add("bbb");
linkList.addLast("ccc");
linkList.addFirst("aaa");
System.out.println(linkList);
}


/*
* Set:无序，不可重复元素\
* HashSet:数据结构是Hash表，线程是非同步的。
* 保证元素的唯一性原理：判断元素的HashCode是否相同，如果相同，还会继续判断元素的equals方法，是否为true。
* 
* TreeSet:底层数据结构是二叉树。 可以对Set中的元素进行排序，对象排序需要 实现Comparable,或者 Comparator 接口
* 保证元素唯一性依据：compareTo 方法 return 0。
*/


/*
* HashSet 主要的特点是：里面不能存放重复元素，而且采用散列的存储方法，所以没有顺序。
*/
@Test
public void hashSetTest() {
Set<String> set = new HashSet<String>();
set.add("b");
set.add("c");
set.add("d");
set.add("b");
set.remove("b");


Iterator<String> it = set.iterator();
while (it.hasNext()) {
String value = it.next();
System.out.println(value);
}
// 使用For Each输出结合
for (String e : set) {
System.out.print(e + " ");
}
}


/*
* TreeSet 可以对Set中的元素进行排序。 底层数据结构是二叉树。 保证元素唯一性依据：compareTo 方法 return 0。
* 存入的元素必须要保证具备排序比较性： 
* 1. 让元素自身具备比较性{ 如果是存放对象， 如果对象没有实现结构 Comparable
* 则会报异常(java.lang.Comparable)， 如果需要使用存入对象并排序， 则需要在对象类 实现 Comparable,
* 让对象具备比较性， 并可在重写 compareTo 方法内自定义业务逻辑得到返回值，实现排序。 按照存入顺序的倒序排序： compareTo
* 方法直接返回 -1 按照存入顺序的升序排序：compareTo 方法直接返回 1 } 
* 2. 让容器自身具备比较性{
* 自定义一个类，实现Comparator 接口，重写 compare 方法 按照存入顺序的倒序排序： compare 方法直接返回 -1
* 按照存入顺序的升序排序：compare 方法直接返回 1 } 
* 注意： 如果元素连两个比较性都存在， 则优先 容器比较器
*/
@Test
public void TreeSetTest() {
// 普通排序
Set<String> set = new TreeSet<String>();
set.add("cc");
set.add("bb");
set.add("aa");
System.out.println(set);


// 对象排序，需要在对象内部实现 Comparable 接口，并重写compareTo 方法自定义业务逻辑得到返回值，实现排序
Set<student> set1 = new TreeSet<student>();
set1.add(new student("afen3", 38));
set1.add(new student("afen1", 48));
set1.add(new student("afen2", 38));
for (student s : set1) {
System.out.println("NAME=" + s.getName() + " -- age=" + s.getAge());
}


System.out.println("====================================");
// 容器排序，需要自定义一个排序类，实现 Comparator 接口，并重写compare 方法自定义业务逻辑得到返回值，实现排序
Set<student> set2 = new TreeSet<student>(new myCompara());
set2.add(new student("afen3", 38));
set2.add(new student("afen1", 48));
set2.add(new student("afen2", 38));
set2.add(new student("afen3", 28));
for (student s : set2) {
System.out.println("NAME=" + s.getName() + " -- age=" + s.getAge());
}
System.out.println("====================================");
// 按照字符串长度排序
Set<String> set3 = new TreeSet<String>(new stringComparator());
set3.add("bb");
set3.add("aa");
set3.add("cccc");
set3.add("ddd");
System.out.println(set3);
}


/*
* Map 
* HashTable ：底层是哈希表数据结构，不可以存入 Null建 Nuull值,该集合是线程同步的。
* HashMap ：底层是哈希表数据结构，可以存入 Null建 Nuull值，该集合是非线程同步的。
* TreeMap ：底层是二叉树数据结构，可以对Map集合中的建进行排序，该集合是非线程同步的。
*/
@Test
public void mapTest(){
Map<String, String> map=new HashMap<String, String>();
map.put("01", "afen");
map.put("02", "xiaofen");
map.put(null, "lisi");
map.put("03", null);
System.out.println("containsKey:"+map.containsKey("01")+", containsValue:"+map.containsValue("afen"));

/* keySet : 获得到Map集合中的所有键形成 Set 集合，因为Set具有迭代器，所以可以通过迭代器遍历出所有的Key，
Map 再通过get获取到对应的值。
*/
Set<String> set=map.keySet();
Iterator<String> it=set.iterator();
while (it.hasNext()) {
String key=it.next();
String value=map.get(key);
System.out.println("key="+key+",value="+value);
}
/*
*  entrySet : 将Map集合的映射关系取出，存入到 Set 集合中
*/
System.out.println("=======================");
Set<Map.Entry<String, String>> set1=map.entrySet();
Iterator<Map.Entry<String, String>> it1=set1.iterator();
while(it1.hasNext()){
Map.Entry<String, String> entry=it1.next();
System.out.println("key="+entry.getKey()+",value="+entry.getValue());
}
/*
* Map 存入对象作为键，需要在对象的内部类重写 HashCode 和 equals 方法， 否则 Map 就会存入相同键的对象
*/
Map<teacher,String> map1=new HashMap<teacher,String>();
map1.put(new teacher("lisi1",30), "beijin");
map1.put(new teacher("lisi2",32), "tianjin");
map1.put(new teacher("lisi3",33), "nanjin");
map1.put(new teacher("lisi3",33), "nanjin");
Iterator<teacher> iter=map1.keySet().iterator();
while (iter.hasNext()) {
teacher t=iter.next();
String value=map1.get(t);
System.out.println("teacher..."+t+", value..."+value);
}
/*
* TreeMap 底层是二叉树数据结构，可以通过key 来排序
*   如果要实现对象排序，和TreeSet一样也要实现 comparator或者comparable 接口
*/
Map<teacher,String> map2=new TreeMap<teacher,String>();
map2.put(new teacher("lisi1",40), "beijin");
map2.put(new teacher("lisi2",30), "tianjin");
map2.put(new teacher("lisi3",20), "nanjin");
map2.put(new teacher("lisi3",20), "nanjin");
Set<Map.Entry<teacher,String>> entry1= map2.entrySet();
Iterator<Map.Entry<teacher,String>> iter1=entry1.iterator();
while (iter1.hasNext()) {
Map.Entry<teacher, String> entry=iter1.next();
System.out.println("teacher:"+entry.getKey()+", adrr:"+entry.getValue());
}
System.out.println("=======================================");
Map<teacher,String> map3=new TreeMap<teacher,String>(new teacherComparator());
map3.put(new teacher("lisi1",40), "beijin");
map3.put(new teacher("lisi2",30), "tianjin");
map3.put(new teacher("lisi3",20), "nanjin");
map3.put(new teacher("lisi3",20), "nanjin");
Set<Map.Entry<teacher,String>> entry2= map3.entrySet();
Iterator<Map.Entry<teacher,String>> iter2=entry2.iterator();
while (iter2.hasNext()) {
Map.Entry<teacher, String> entry=iter2.next();
System.out.println("teacher:"+entry.getKey()+", adrr:"+entry.getValue());
}
}

/*
* Map 练习
* 获取字符串字符出现的字数 以 a(3), b(4) 事列显示
*/
@Test
public void pringCharCount(){
Set<Map.Entry<Character, Integer>> set=this.charCount("abcdefabaacf").entrySet();
Iterator<Map.Entry<Character, Integer>> it=set.iterator();
while(it.hasNext()){
Map.Entry<Character, Integer> entry=it.next();
System.out.println(entry.getKey()+"("+entry.getValue()+") ");
}
}

public Map<Character,Integer> charCount(String str){
char[] c=str.toCharArray();
Map<Character,Integer> map=new TreeMap<Character,Integer>();
for (int i = 0; i < c.length; i++) {
int num=map.get(c[i])==null?1:map.get(c[i])+1;
map.put(c[i], num);
}
return map;
}


@Test
public void ArrayListToString() {
ArrayList<String> als = new ArrayList<String>();
als.add("aa");
als.add("bb");
String[] s = (String[]) als.toArray(new String[0]);
System.out.println(s[1]);
}


@Test
public void ListToString() {
List<String> list = new ArrayList<String>();
list.add("aa");
list.add("bb");
String[] strArr = new String[list.size()];
strArr = list.toArray(strArr);
System.out.println(strArr[1]);
}
}