集合（Collection,set,list,map)

package cn.hncu.col.col;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class CollectionDemo {

public static void main(String[] args) {

Collection col = new ArrayList(); //addA(Object obj); --List的实现类
//Collection col = new HashSet(); //--Set的实现类--重复元素是加不进的，元素的排列序列由各元素的hashCode值来决定

//增
col.add(1);
col.add("abc");
col.add(100.123);
col.add("asd");
//col.add(1);//如果该Collection用的是Set的实现类，那么重复的元素是加不进的
col.add( new Person("Jack",22) );

//删除
//col.remove("abc");
//String str = new String("abc");
//col.remove(str);

//修改1(对于Set实现，这种方式可以。而List实现不行，顺序乱了)
//col.remove("abc");
//col.add("abc123");

//修改2
Object[] objs = col.toArray();
col.clear();
for(int i=0;i<objs.length;i++){
if(objs[i].equals("abc")){
objs[i] = "abc123";
}
col.add(objs[i]);
}

//查
//集合遍历---工具：Iterator
Iterator it = col.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}

}

}

----------------------------------------------

package cn.hncu.col.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//有序，允许重复。总的来讲: List中的功能是在Collecton的基础上还添加了“与下标索引”有关的操作
/*
* 1, List当中，元素添加的顺序和存入的顺序是一样的---跟hashCode没有关系
* 2, List当中有一些“与位置-index”有关的操作
* 3, List当中有一个ListIterator列表迭代器，既可以next()，也可以previous()----而Collection当中的Iterator只能next()
*/
public class ListDemo {

public static void main(String[] args) {
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add(0,"d");//在基础上增加的---与index有关的操作

list.add(new Person("Rose",23));
list.add(new Person("Jack",25));
list.add(new Person("Jack",25));
list.add(new Person("Tom",22));

//删除
//list.remove("b");
//list.remove(2);

//修改
//list.set(3,"ccc");//修改第3个位置的元素
int index = list.indexOf("c");
list.set(index, "ccccc");

//遍历法1：用迭代器
// Iterator it = list.iterator();
// while(it.hasNext()){
// System.out.println(it.next());
// }
//遍历法2：利用与位置有关的操作，直接采用for循环
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}

}

}

----------------------------------------------------

package cn.hncu.col.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

//有序，允许重复。总的来讲: List中的功能是在Collecton的基础上还添加了“与下标索引”有关的操作
/*
* 1, List当中，元素添加的顺序和存入的顺序是一样的---跟hashCode没有关系
* 2, List当中有一些“与位置-index”有关的操作
*/
public class ListDemo2 {

public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add("a");
list.add("b");
list.add("c");
list.add(new Person("Jack",25));
list.add(new Person("Tom",22));

//※※LinkedList当中特有的方法
//list.addFirst("11111");
list.addLast("22222");
list.removeFirst();
//list.removeLast();
//getFirst()、getLast()

//遍历法2：利用与位置有关的操作，直接采用for循环
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}

}

------------------------------------------------------------

package cn.hncu.col.list;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class MyStack {
//private List list = new ArrayList();//允许重复，有序
private List list = new LinkedList();//允许重复，有序--中间元素有频繁的插入和删除，选这个

//入栈
public void push(Object obj){
list.add(obj);
}

//出栈
public Object pop(){
if(list.size()>0)
return list.remove( list.size()-1 );
else
return null;
}

//大小
public int size(){
return list.size();
}

public static void main(String[] args) {
MyStack stack = new MyStack();
stack.push("a");
stack.push("b");
stack.push(new Person("Mike",20));
stack.push(100);

for (int i = 0; i < 5; i++) {
System.out.println(stack.pop());
}
}

}

----------------------------------------------------

package cn.hncu.col.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

//无序，不允许重复。总的来讲: Set中的全部功能都来自Collecton，自己没有添加新的功能
public class HashSetDemo {
/*
* 1,如果Person类中没写hashCode()，那么构造两个相同的Person对象也能加进Set集合，因此此时的HashCode是内存地址。而如果写了hashCode()方法，则第二个加不进。
* 2,set.add(e)方法执行时，内部会调用一次e对象的hashCode()方法(其实根据它的返回值来决定元素存放位置)
* 3,如果Person类中没写hashCode()，加入到集合中的这些元素的顺序是不确定的(因为此时各元素的位置由内存地址来决定的)
*/
public static void main(String[] args) {
Set set = new HashSet();
set.add(new String("Java"));
set.add( new Person("Jack",23) );//hashCode
set.add( new Person("Jack",23) );//加不进，相同的hashCode处，只能加入一个元素
set.add( new Person("Tom",23) );
set.add( new Person("张三",22) );
set.add(new Integer(100) );
set.add(new Double(100.123) );

//Set一般都是用迭代器(专门的查询组件)来遍历
Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
//区分集合当中元素的类型 ---instanceof
if(obj instanceof Person){
System.out.println("Person对象:"+obj);
}else if(obj instanceof Integer || obj instanceof Double){
System.out.println("数值:"+obj);
}else{
System.out.println(obj);
}
}

}

}

--------------------------------------------------------------

package cn.hncu.col.sort.v1;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class SortDemo1 {

public static void main(String[] args) {
//Set set = new HashSet();//HashSet是无法实现:自定义排序
Set set = new TreeSet();//TreeSet可以实现:自定义排序 ----凡是Tree都能实现自定义排序
//凡是插入TreeSet中的元素应该都是能够排序的，即要实现Comparable接口
//TreeSet中的add()方法被调用时，会自动让被添加元素去调用它的compareTo()方法以决定该元素的顺序
set.add(new Person("Jack",102));
set.add(new Person("Tom",23));
set.add(new Person("Mike",32));
set.add(new Person("张三",33));
set.add(new Person("Rose",24));

Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}

}

--------------------------------------------------------------

package cn.hncu.col.sort.v2;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class SortDemo2 {

public static void main(String[] args) {
//Set set = new HashSet();//HashSet是无法实现:自定义排序
Set set = new TreeSet();//TreeSet可以实现:自定义排序 ----凡是Tree都能实现自定义排序
//凡是插入TreeSet中的元素应该都是能够排序的，即要实现Comparable接口
//TreeSet中的add()方法被调用时，会自动让被添加元素去调用它的compareTo()方法以决定该元素的顺序

set.add("abc");
set.add("aaa");

set.add(new Person("Jack",102));
set.add(new Person("Tom",23));
set.add(new Person("Mike",32));
set.add(new Person("Mik",32));
set.add(new Person("张三",32));
set.add(new Person("Rose",24));

//set.add("abc");//因为String类中没有compartTo(Person)的方法，所以在这个地方添加不行。
//set.add("aaa");

Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}

}

--------------------------------------------------------

package cn.hncu.col.sort.v3;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class SortDemo3 {

public static void main(String[] args) {
//Set set = new TreeSet();//TreeSet是要排序的。如果是空参构造方法，那么顺序由被添加元素来决定(使用它的Comparable接口)---排序方法1
Comparator cmp= new MyCmp();
Set set = new TreeSet(cmp);//使用有Comparator参数的构造。利用cmp比较器来进行排序，不会使用被添加元素的Comparable接口
set.add("abc");
set.add("aaa");

set.add(new Person("Jack",102));
set.add(new Person("Tom",23));
set.add(new Person("Mike",32));
set.add(new Person("Mik",32));
set.add(new Person("张三",32));
set.add(new Person("Rose",24));

//set.add("abc");
//set.add("aaa");

Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}

}

-------------------------------------------------

package cn.hncu.col.sort.v3;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

public class SortDemo4 {

public static void main(String[] args) {

//如果是TreeMap，是按key来排序的
Comparator cmp= new MyCmp();
Map map = new TreeMap(cmp);//使用有Comparator参数的构造。利用cmp比较器来进行排序，不会使用被添加元素的Comparable接口
// map.put(1, "abc");
// map.put(2, "aaa");

map.put(3, new Person("Jack",102));
map.put(4, new Person("Tom",23));
map.put(5, new Person("Mike",32));
map.put(6, new Person("Mik",32));
map.put(7, new Person("张三",32));
map.put(8, new Person("Rose",24));

map.put(9, "abc");
map.put(81, "aaa");

Iterator it = map.entrySet().iterator();
while(it.hasNext()){
Entry en = (Entry) it.next();
System.out.println(en.getKey()+":"+en.getValue());
}
}

}

------------------------------------------------------------

****中文排序

package cn.hncu.col.sort.v4;

import java.util.Iterator;
import java.util.TreeMap;
import java.util.Map.Entry;

public class ChineseSort {
public static void main(String[] args) {
TreeMap map = new TreeMap( new MyCmp2() );
map.put("周平", new Person("周平",10));
map.put("张三", new Person("张三",22));
map.put("李四", new Person("李四",34));
map.put("一丁", new Person("一丁",3));

Iterator it = map.entrySet().iterator();
while(it.hasNext()){
Entry en = (Entry) it.next();
System.out.println("key="+en.getKey()+",,,value="+en.getValue());
}
}
}

---==================--------

package cn.hncu.col.sort.v4;

import java.text.CollationKey;
import java.text.Collator;
import java.util.Comparator;
/**
* 中文排序的比较器
* @author <a href="mailto:729627398@qq.com">hncu_lzp</a>
* @version 1.0 2016-7-15
*/
public class MyCmp2 implements Comparator {
private Collator collator = Collator.getInstance();
@Override
public int compare(Object o1, Object o2) {

CollationKey key1 = collator.getCollationKey(o1.toString());
CollationKey key2 = collator.getCollationKey(o2.toString());
return key1.compareTo(key2);//把key1和key2交换一下，则是反序排序
}
}

----------------------------------------------------------------------

package cn.hncu.col.sort.v1;

public class Person implements Comparable{
private String name;
private int age;

public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}

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 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;
}

@Override
public String toString() {
return name + "," + age;
}

=====这里公用一个person类，有的要hashcode和equals方法，有的不需要。下面是因为要用到Tree。

//由该方法的返回值来决定元素this和o之后的大小
/**
* 计算：this - o
* 如果this>o 返回 >0的整数
* 如果this<o 返回 <0的整数
* 如果this==o 返回 0
*/
@Override
public int compareTo(Object o) {
//System.out.println("a.........");
//return 1; //后加的元素更大，按添加的次序依次排(输出)
//return -1; //后加的元素更小，按添加的次序的倒序排(输出)
Person p = (Person) o;
//return this.age - p.age;//按年龄升序
return p.age - this.age;//按年龄倒序
}

}

-----------------------------------------------------

package cn.hncu.col.sort.v1;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class SortDemo1 {

public static void main(String[] args) {
//Set set = new HashSet();//HashSet是无法实现:自定义排序
Set set = new TreeSet();//TreeSet可以实现:自定义排序 ----凡是Tree都能实现自定义排序
//凡是插入TreeSet中的元素应该都是能够排序的，即要实现Comparable接口
//TreeSet中的add()方法被调用时，会自动让被添加元素去调用它的compareTo()方法以决定该元素的顺序
set.add(new Person("Jack",102));
set.add(new Person("Tom",23));
set.add(new Person("Mike",32));
set.add(new Person("张三",33));
set.add(new Person("Rose",24));

Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}

}

--------------------