java Collection 个人记录和记忆

import java.util.*;
import java.util.function.Function;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;

/**
* Created by Kodulf on 2017/4/6.
*/
public class CollectionTest {

/**
* 苍老师mv（c collection，l list，s set，m，map，v vector
* 钻石无或配不上，咋啊双人床无或配不上，挨扁不用初中生
* list 你（list）瞎掰，挨g人是sb，来了挨g人服了。
* set，谁，嘿嘿等顺序，停车c大吼排嘘。
*
*
* 钻石无或配不上，咋啊双人床无或配不上，挨扁不用初中生
* c 钻石无或配不上，z增 增加add，addAll，s删除，remove，clear，无或 没有获得，p配 判断isEmpty，b不 遍历Iterator，s上 转数组
* 咋啊双人床无或配不上，遍历的时候不能够在遍历的里面使用collection进行增删，必须使用iterator进行
* 在Iterator 遍历里面，不要用collection的对象进行增删，挨扁不用初中生，（ai Iterator,b遍历，不用，collection进行 z增s删）
*
*
* list 你（list）瞎掰，挨锅人是sb，来了挨锅人服了。
* agrssb 瞎掰，挨锅人是sb。增删获更遍历都可以通过下标来的，ListIterator 可以在里面直接进行遍历的时候进行add和set。
* List： 是有顺序的，分为ArrayList(列表) 和 LinkedList（链表）
* List 都是有下表的，增删获更遍历都可以通过下标来的。arsgsb 阿仁是个sb。
* ListIterator 可以在里面直接进行遍历的时候进行add和set，
* LinkedList 来了挨锅人服了。linkedlist来了，add挨，get锅，remove人，fisrt服，last了
* list 里面判断是否包含的contains 是通过equals 来判断的，如果是String就是内容，如果是对象就是地址，基本数据类型就是值
*
* set，谁，嘿嘿，等顺序，停车c大吼排嘘。(车c compareTo,comparator)
* HashSet,TreeSet
* 首先并不是都是要比较equals的方法的，
* hashset 首先比较的是hashcode，如果hashcode相等，那么在判断equals
* treeset，比较的只有是compareTo,comparator,带有排序的功能，但是必须是相同的类，不然如果出现了Student和String，那么就不好辨识了。除非重写Student的compareto方法
* compareTo里面使用的是本地的减去被比较的，如果大于说明就是要排在被比较的后面，一般都是和前面的进行比较的，所以如果大于，那么输出的时候直接就是在后面了，如果将某一个类的compareTo设置为1那么后面添加的一定排在前面添加的后面
* 大吼排嘘，大的放在后面，treeset可以利用这点进行排嘘
*
*
*
*
*
* @param args
*/
public static void main(String[] args){

testCollection();

testList();

testAddAndRemoveIterator();

testAddAndRemoveListIterator();

testVector();

testLinkedList();

testMoNiDuiZhan();

testRemoveDuty();

testCeshiDuixiangEquals();

testHashSet();

testTreeSetWithComparator();

testHashSetAndTreeSet();

testHashOrder();

}

/**
* 注意了Collection, Collections 是不同的Collections 是工具类，可以用来进行排序的
* 钻石配不上，z增，s删除，p判断，b遍历，s数组
*/
private static void testCollection() {

Collection collection  = new ArrayList();
collection.add("aa");
collection.add("bb");
collection.add("cc");
collection.add(99);

System.out.println(collection);
Collection coll2 = new ArrayList();
coll2.add("dd");
coll2.add("ee");

collection.addAll(coll2);
System.out.println(coll2);
System.out.println(collection);

//删除
collection.remove(99);
coll2.clear();
System.out.println(collection);

//判断
System.out.println(collection.contains(99));
System.out.println(collection.isEmpty());
System.out.println(collection.size());

//遍历
Iterator iterator = collection.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
System.out.println(next);
}

//集合转数组
Object[] objects = collection.toArray();
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
}

/**
* list的特点，可以带下标，也可以通过下表遍历
*/
public static void testList(){
List col = new ArrayList();
col.add("aa");
col.add("bb");
col.add("cc");
col.add(0,"00");

System.out.println(col);

col.remove(0);
System.out.println(col);

col.set(2,"22");
System.out.println(col);

System.out.println(col.get(2));

System.out.println(col.subList(0,1));

Iterator iterator = col.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}

for (int i = 0; i < col.size(); i++) {
System.out.println(col.get(i));
}

while (!col.isEmpty()){
System.out.println(col.remove(0));
}
}

/**
* 测试list的iterator
*  在迭代的过程中使用集合对集合中的对象进行添加，删除，例如：col.remove("cc"); 修改会发生ConcurrentModificationException
*/
public static void testAddAndRemoveIterator(){
List col = new ArrayList();
col.add("aa");
col.add("bb");
col.add("cc");

Iterator iterator = col.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
if("cc".equals(next)){
System.out.println(next);
try {
iterator.remove();
}catch (Exception e){
e.printStackTrace();
}
}else {
System.out.println(next);
}
}
System.out.println(col);
}

/**
*  在迭代的过程中使用集合对集合中的对象进行添加，删除，例如：col.remove("cc"); 修改会发生ConcurrentModificationException
*  相比于Iterator ListIterator 可以进行添加
*/
public static void testAddAndRemoveListIterator(){
List col = new ArrayList();
col.add("aa");
col.add("bb");
col.add("cc");

ListIterator listIterator = col.listIterator();
while (listIterator.hasNext()){
Object next = listIterator.next();
if("cc".equals(next)){
//在迭代的过程中使用集合对集合中的对象进行添加，删除，例如：col.remove("cc"); 修改会发生ConcurrentModificationException
//col.remove("cc");

listIterator.remove();
//相比于Iterator ListIterator 可以进行添加
listIterator.add("hahhahahah ");
}else {
System.out.println(next);
}
}

System.out.println(col);
}

public static void testVector(){
Vector v = new Vector();
v.add("haha");
v.add("hehe");
v.add("xixi");

Enumeration elements = v.elements();
while (elements.hasMoreElements()){
System.out.println(elements.nextElement());
}
}

public static void testLinkedList(){
LinkedList linkedList = new LinkedList();
linkedList.add("11");
linkedList.add("22");
linkedList.add("33");
linkedList.add("44");

linkedList.addFirst("first");
linkedList.addLast("last");
System.out.println(linkedList);

System.out.println(linkedList.getFirst());
System.out.println(linkedList.getLast());

linkedList.removeFirst();
linkedList.removeLast();
System.out.println(linkedList);

linkedList.offerFirst("offerFirst");
linkedList.offerLast("offerLast");

System.out.println(linkedList.peekFirst());
System.out.println(linkedList.peekLast());

Object o = linkedList.pollFirst();
linkedList.pollLast();
System.out.println(linkedList);
}

/**
* 模拟堆栈
*/
public static void testMoNiDuiZhan(){
Dui dui = new Dui();
dui.in("1");
dui.in("2");
dui.in("3");
dui.chu();
System.out.println(dui.linkedList);

Zhan zhan = new Zhan();
zhan.in("1");
zhan.in("2");
zhan.in("3");
zhan.chu();
System.out.println(zhan.linkedList);
}

/**
* 队,先进先出，addLast,getFirst
*/
static class Dui{
LinkedList linkedList = new LinkedList();

public Dui(){

}

public void in(Object object){
linkedList.addLast(object);
}

public Object chu(){
Object ret= new Object();
if(linkedList.size()>0)
ret = linkedList.removeFirst();
return ret;
}

}

/**
* 栈，先进后出，addLast,getLast
*/
static class Zhan{
LinkedList linkedList = new LinkedList();
public Zhan(){

}

public void in(Object object){
linkedList.addLast(object);
}

public Object chu(){
Object ret= new Object();
if(linkedList.size()>0)
ret = linkedList.removeLast();
return ret;
}
}

/**
* 去除重复的数据
*/
public static void testRemoveDuty(){
ArrayList arrayList = new ArrayList();
arrayList.add("hello world");
arrayList.add("bbbbbbbbbbb");
arrayList.add("bbbbbbbbbbb");
arrayList.add("bbbbbbbbbbb");

ArrayList newArrayList = quchu(arrayList);

System.out.println(newArrayList);

quchuwithIterator(arrayList);
System.out.println("测试final 修饰的对象");
System.out.println(arrayList);
}

/**
* 去除重复的
* @param arrayList
* @return
*/
private static ArrayList quchu(ArrayList arrayList) {
ArrayList newArrayList = new ArrayList();

for (int i = 0; i < arrayList.size(); i++) {
if(newArrayList.contains(arrayList.get(i))){

}else{
newArrayList.add(arrayList.get(i));
}
}
return newArrayList;
}

/**
* 去除重复的，如果使用Iterator 的话，那么原来的ArrayList 也会改变的的
* 这个就是值传递里面的对象，地址不变，但是里面的内容会改变的，原来的对象相当于是用final 修饰了，虽然地址不变，但是里面的内容是可以改变的
* @param arrayList
* @return
*/
private static ArrayList quchuwithIterator(ArrayList arrayList) {
ArrayList newArrayList = new ArrayList();

ListIterator listIterator = arrayList.listIterator();
while (listIterator.hasNext()){
Object next = listIterator.next();
listIterator.remove();
}
return newArrayList;
}

private static void testCeshiDuixiangEquals(){
ArrayList<Student> arrayList = new ArrayList();
arrayList.add(new Student(12,"Hellen"));
arrayList.add(new Student(13,"Hellen3"));
arrayList.add(new Student(14,"Hellen4"));
arrayList.add(new Student(15,"Hellen5"));
arrayList.add(new Student(12,"Hellen"));
arrayList.add(new Student(12,"Hellen"));

ArrayList quchu = quchu(arrayList);
System.out.println(quchu);

}

static class Student implements Comparable{

Student(int age,String name){
this.age  = age;
this.name = name;
}

int age;
String name;

/**
* 如果不重写hashcode，那么hashset里面添加的时候是有问题的，就是即使equals的方法重写了，但是没有重写hashcode 也是没有用到的
* 但是ArrayList的contains里面值判断equals的方法
* @return
*/
@Override
public int hashCode() {
System.out.println("hashcode");
int i = this.age + (int) (Math.random() * 100);
System.out.println(i);
return i;
}

@Override
public boolean equals(Object obj) {

boolean ret = false;

if(obj instanceof Student){
Student target = (Student) obj;
if(target.age == this.age && StringUtil.isNotEmpty(target.name)&&StringUtil.isNotEmpty(this.name)&&this.name.equals(target.name)){
ret = true;
}
System.out.println("比较里面的："+(ret?"相同":"不相同"));
}
System.out.println(ret?"相同":"不相同");
return ret;
}

@Override
public String toString() {

return "age="+this.age+" name="+this.name;
}

@Override
public int compareTo(Object o) {
int ret = 0;
if(o instanceof Student){
Student o1 = (Student) o;
ret = this.age - o1.age;
if(ret == 0){
ret = this.name.compareTo(o1.name);
}
}
System.out.println(ret);
return 0;
}
}

/**
* 测试hashset，注意了，这里面如果使用上面的重写equals的Student的，那么还是不会过滤掉这里面的多余的Student，除非重写了hashcode的方法
* HashSet吗，hash吗，所以要判断has，
*/
public static void testHashSet(){
HashSet hashSet = new HashSet();

hashSet.add("hello");
hashSet.add("hello1");
hashSet.add("hello");
hashSet.add("hello");

hashSet.add(new Student(12,"hello12"));
hashSet.add(new Student(12,"hello12"));
hashSet.add(new Student(12,"hello12"));
hashSet.add(new Student(12,"hello12"));

System.out.println(hashSet);
}

/**
* 测试treeset，默认的会进行排序的
*/
public static void testTreeSet(){
TreeSet treeSet = new TreeSet();

treeSet.add("123456789");
treeSet.add("1234567892");
treeSet.add("1234567891");
treeSet.add("1234567895");
treeSet.add("1234567893");

System.out.println(treeSet);
}

/**
* Tree 相关的都是要进行比较的,两种方式：
* 1：是被比较的类实现了Comparable的接口，
* 2：自定义一个Comparator去实现Comparator
*/
public static void testTreeSetWithComparator(){
MyComparator myComparator = new MyComparator();

//方法一：被比较的类实现Comparable的接口
TreeSet treeSet = new TreeSet();

//TreeSet treeSet = new TreeSet(myComparator);

treeSet.add(new Student(12,"jack1"));
treeSet.add(new Student(12,"jack1"));
treeSet.add(new Student(12,"jack3"));
treeSet.add(new Student(12,"jack4"));
treeSet.add(new Student(12,"jack5"));

System.out.println(treeSet);
}

static class MyComparator implements Comparator<Student> {

@Override
public int compare(Student o1, Student o2) {

//首先比较age，然后比较name
int ret = 0;
ret = o1.age -o2.age;
if(ret ==0){
ret = o1.name.compareTo(o2.name);
}
return ret;
}

}

//
static void testHashSetAndTreeSet(){
HashSet hashSet = new HashSet();
hashSet.add("000");
hashSet.add("234");
hashSet.add("345");
hashSet.add("000");
hashSet.add(new Student(12,"12"));
hashSet.add(new Student(12,"122"));
hashSet.add(new Student(12,"1222"));
hashSet.add(new Student(12,"12222"));
hashSet.add(new Student(12,"122222"));
System.out.println(hashSet);

System.out.println("————————————————————");
TreeSet treeSet = new TreeSet();
//        treeSet.add("098");
//        treeSet.add("099");
//        treeSet.add("100");
//        treeSet.add("096");
//        treeSet.add("092");
treeSet.add(new Student(12,"222222"));
treeSet.add(new Student(12,"122"));
treeSet.add(new Student(12,"1222"));
treeSet.add(new Student(12,"12222"));
treeSet.add(new Student(12,"122222"));
System.out.println(treeSet);
}

/**
* 测试hash的排列的顺序
*/
private static void testHashOrder() {
TreeSet hashSet = new TreeSet();

hashSet.add("abc");
hashSet.add("1");
hashSet.add("12");
hashSet.add("890");
hashSet.add("bcd");
System.out.println(hashSet);
}

}