Java集合框架的学习

Java集合框架的学习

集合，装引用类型的容器，可以装对象，主要学习各种容器的使用方法
1、添加元素
2、删除元素
3、判断元素是否存在，为空
4、遍历元素方法：根据集合的特性有不同的遍历方法
a、for 循环遍历
b、增强for遍历
c、迭代器遍历

代码中有很多学习时的注释，有需要的可以看看

package Gather;

import com.sun.org.apache.xpath.internal.objects.XObject;

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

/**
 * Collection 接口的使用
 * 1、添加元素
 * 2、删除元素
 * 3、遍历元素
 * 4、判断元素是否存在，是否为空
 * @author li
 *
 * */

public class Demo {
    public static void main(String[] args) {
        //创建对象
        Collection o1 = new ArrayList();
        o1.add("苹果");
        o1.add("梨");
        o1.add("香蕉");
        o1.add("橘子");
        o1.add("樱桃");
        System.out.println("水果个数为为："+o1.size());
        System.out.println("使用增强for");
        for (Object object :o1);//增强for
        System.out.println(o1);
        //迭代器（一种专门遍历集合的一种方式）
        Iterator it = o1.iterator();//Iterator 类型的的对象专门遍历集合
        //hasNext方法，判断有没有下一个元素
        //next 获取下一个元素
        //remove 删除，
        while (it.hasNext()){
            String s = (String)it.next();
            System.out.println(s);
            //Iterator 迭代器内不能使用 collection 的方法
          it.remove();//删除全部

        }
        System.out.println("删除后的元素为："+o1.size());


    }
}

package Gather;

import java.util.ArrayList;
import java.util.Collection;

public class Demo1 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();//通过ArrayList()实例化对象
        Student s1 = new Student("zhangsan",20);
        Student s2 = new Student("lisi",20);
        Student s3 = new Student("wanger",20);
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);

        System.out.println(collection.size());//collection 对象的大小
        System.out.println(collection.toString());//采用Collection.tostring 方法打印collection中的元素
        System.out.println(collection.contains(s2));//contains(s2)方法判断是否含有元素s2
    }
}

package Gather;

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

public class Demo2 {
    public static void main(String[] args) {
        //创建list 集合
        List list = new ArrayList();
        //添加数字到集合里面，（自动装箱）
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        list.add(70);
        System.out.println("list集合中的元素个数为："+list.size());
        System.out.println(list.toString());
        //删除操作
        list.remove(2);
        System.out.println(list.toString());
        //补充方法 sublist ,返回集合，含头不含尾
        System.out.println(list.subList(1,3));//左闭右开
    }
}

``

```java
package Gather;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

public class Demo4 {
    public static void main(String[] args) {
        //实例化对象
        LinkedList<Object> objects = new LinkedList<>();
        Student s1 = new Student("shh",10);
        Student s2 = new Student("gdfhg",156);
        Student s3 = new Student("gsfdh",15);
        Student s4 = new Student("gaga",14);
        objects.add(s1);
        objects.add(s2);
        objects.add(s3);
        objects.add(s4);
        System.out.println("元素的个数为："+objects.size());
        System.out.println(objects.toString());

        System.out.println("使用for+++++++++");
        for (int i = 0; i < objects.size(); i++) {
            System.out.println(objects.get(i));


        }
        //才能使用 listIterator(功能更加强大，可以从前往后，也能从后往前)
        Iterator iterator = objects.iterator();//用实例化的对象才能使用collection 的迭代器Iterator
        while (iterator.hasNext()){
            System.out.println(iterator.toString());
        }
        //使用Arrayslist实例化的对象objects 来使用list 的迭代器listIterator
        ListIterator lis = objects.listIterator();
        while (lis.hasNext()){
            System.out.println(lis.next());
            System.out.println(lis.toString());
            System.out.println(objects.contains(s1));
            System.out.println(objects.indexOf(s4));
        }
    }

}

package Gather;

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

//set子接口的使用，无下标，不能重复，无序
public class Demo5 {
    public static void main(String[] args) {
        //创建集合
        Set<String> set = new HashSet<>();
        //添加元素
        set.add("xioami");
        set.add("pignguo");
        set.add("huawei");//打印顺序与添加元素的位置不一致
        System.out.println(set.size());
        System.out.println(set.toString());
        //删除元素
        set.remove("xioami");
        System.out.println(set.toString());
        //遍历，无下标，增强for
        for (String s:
        set) {
            System.out.println(s);

        }
        //迭代器
        Iterator<String> it = set.iterator(); //set对象使用迭代器
        while (it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println(set.contains("xioami"));//已删故没有此元素


    }
}

package Gather;

import java.util.Iterator;
import java.util.TreeSet;

/*
* TreeSet 的使用
* 结构为红黑树
* */
public class Demo6 {
    public static void main(String[] args) {
        //创建集合
        TreeSet<String> objects = new TreeSet<>();
        //加入元素
        objects.add("sdfg");
        objects.add("xyz");
        objects.add("abc");
        objects.add("ssgsag");
        System.out.println("元素个数为："+objects.size());
        System.out.println(objects.toString());
        //删除操作
        objects.remove("xyz");
        System.out.println(objects.toString());
        //遍历
        for (String string:objects
             ) {
            System.out.println(string);
        }
        //使用迭代器
        Iterator<String> it = objects.iterator();
        while (it.hasNext())
        System.out.println(it.next());
        //判断
        System.out.println(objects.contains("abc"));

    }
}

package Gather;

import java.util.Iterator;
import java.util.TreeSet;

public class Demo8 {
    public static void main(String[] args) {
        //TreeSet 类实现Comparable 接口，所以要实现Comparable接口中的compareTo（）方法
        TreeSet<Student> t1 = new TreeSet<>();
      //将对象s1 加入集合对象TreeSet 中会报异常
        //不能将Student转换为Comparable类型

        Student s1 = new Student("dhig",156);
        Student s2 = new Student("dhgf",54);
        Student s3 = new Student("jh",24);//重写compare接口中的compareTo（）方法，告知比较规则后方能将其他类型的对象加入TreeSet类型的集合中


        t1.add(s1);//报异常Student cannot be cast to java.lang.Comparable
        t1.add(s2);//红黑树的定义，没有比较的标准，
        t1.add(s3);
        System.out.println(t1.size());
        System.out.println(t1.toString());
        System.out.println("====================================");
        //删除元素
        t1.remove(s1);
        System.out.println(t1.toString());
        System.out.println("==================================");
        //增强for遍历
        System.out.println("==============使用增强for遍历==========");
        for (Student student:t1
             ) {
            System.out.println(t1.toString());
        }
        //迭代器遍历
        System.out.println("================使用迭代器遍历==============");
        Iterator<Student> student = t1.iterator();//t1集合对象使用迭代器iterator 遍历后放入Student 类型的容器中
        while (student.hasNext()){
            System.out.println(student.next());
        }
        System.out.println("==========判断==========================");
        System.out.println(t1.contains(s1));//检查集合对象中是否有此元素
        System.out.println(t1.isEmpty());
    }
}

package Gather;
/*
TreeSet 类似有于字典
* TreeSet集合的使用
* Comparator:实现当前定制比较（比较器）
* 不用实现Comparable 接口中的方法，直接再当前类中制定比较规则
* */
import java.util.Comparator;
import java.util.Comparator;
import java.util.TreeSet;

public class Demo9 {
    public static void main(String[] args) {
        TreeSet<Student> stu = new TreeSet<>(new Comparator<Student>(){

            @Override
            public int compare(Student o1,Student o2) {
                int n1 = o1.getAge()-o2.getAge();
                int n2 = o1.getName().compareTo(o2.getName());
                return n1==0?n2:n1;
            }
        });
        Student s1 = new Student("dhig",156);
        Student s2 = new Student("dhgf",54);
        Student s3 = new Student("jh",24);//重写compare接口中的compareTo（）方法，告知比较规则后方能将其他类型的对象加入TreeSet类型的集合中


        stu.add(s1);//报异常Student cannot be cast to java.lang.Comparable
        stu.add(s2);//红黑树的定义，没有比较的标准，
        stu.add(s3);
        System.out.println(stu.toString());
    }

}

package Gather;

import java.util.Comparator;
import java.util.TreeSet;

/*
* 实现字符串的比较，默认按长度排序，长度相同则按照字母顺序排列
*
*
* */
public class Demo10 {
    public static void main(String[] args) {
        TreeSet<String> s2 = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int n1 = o1.length()-o2.length();//长度比较长度较长的在后面
                int n2 = o1.compareTo(o2);//按照原来的字符串比较规则，字母表顺序优先
                return n1==0?n2:n1;//返回n1==0吗 等于就返回n2 否则返回n1
            }
        });
        s2.add("sdhsud");
        s2.add("xian");
        s2.add("xagh");
        s2.add("hgaudhad");
        s2.add("sdgh");
        s2.add("sdhgf");
        System.out.println(s2.toString());

    }
}

package Gather;

import java.util.*;

public class Demo11 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(256);
        list.add(565);
        list.add(252);
        list.add(125);
        //排序sort
        System.out.println("排序之前为："+list.toString());
        Collections.sort(list);
        System.out.println("排序之后为："+list.toString());
    //二分查找 binarySeach
        int a = Collections.binarySearch(list,7);
        System.out.println(a);
        //copy 复制
        ArrayList<Integer> objects = new ArrayList<>();
        for (int k = 0; k < list.size(); k++) {
            objects.add(0);
        }
        Collections.copy(objects,list);//复制的时候应该注意，两个集合的大小不一致，应保证两个集合的大小相同
        System.out.println(objects.toString());
        //反转 reverse
        Collections.reverse(list);
        System.out.println("反转之后："+list.toString());
        //打乱 shuffle
        Collections.shuffle(list);
        System.out.println("打乱之后："+list.toString());
        //补充 list 转成数组
        Integer[] arrays = list.toArray(new Integer[0]);
        System.out.println(arrays.length);
        System.out.println(Arrays.toString(arrays));
        //数组转为集合
        String[] name = {"zhangsan","asg","shdf"};
        List<String> intege = Arrays.asList(name);//数组转为集合
        System.out.println(intege.toString());
        Integer[] s = {100,200,332,32,351325};
        List<Integer> li = Arrays.asList(s);//转换为列表后注意装的容器的类型，比须对应
        System.out.println(li);
    }

}

package Gather;
/*
*
*
* */


public class Student implements Comparable<Student>{
    private String name;
    private int age;



    public Student(String name, int age) {//Ait+Insert 添加构造方法
        this.name = name;
        this.age = age;
    }
    //一下是外部类调用内部属性的方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
//重写tostring方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写CompareTo 方法
    //比较规则，先比姓名，再比年龄
    @Override//重写compare接口中的compareTo（）方法，告知比较规则后方能将其他类型的对象加入TreeSet类型的集合中
    public int compareTo(Student o) {
        int n1 = this.getName().compareTo(o.getName());
        int n2 = this.age-o.getAge();

        return n1==0?n2:n1;
    }
}

---

云边有个小卖部