Java基础__Java中集合类

 

 

　　ArrayList：有序、可重复、线程不安全、内部使用数组进行存储

　　LinkedList：有序、可重复、线程不安全、内部使用引用进行存储【可以很方便的进行插入、删除数据】

　　Vector：有序、可重复、线程安全

　　HastSet：无序、不可重复(自动去重)

　　　　TreeSet存放数据是有序的

　　　　HashSet存放数据是无序的

 

 

 

一、ArrayList集合类的简单创建和使用

　　创建一个集合对象

　　ArrayList arr = new ArrayList();

 

　　往集合中添加数据【arr.add(Object)】

    arr.add("小明");

 

　　通过索引从集合中取得对象【arr.get(Index)】

　　arr.get(1)

 

 

package com.Gary.arryaylist;

import java.util.ArrayList;

public class ArrayListDemo {

       public static void main(String[] args){
        //集合对象
        ArrayList arr = new ArrayList();
        
        //往集合中添加对象
        arr.add("小明");
        arr.add("小红");
        arr.add("小梁");
        
        //使用索引添加对象
        System.out.println(arr.get(0));
        
    }
    
}

 

 

二、ArrayList集合里面数据的添加和数据的遍历

　　往一个集合中添加一个集合(多条数据)

    //创建多条数据
    ArrayList arr2 = new ArrayList();
    arr2.add("Gary");
    arr2.add("Gary2");

    // 往集合中添加多条数据
    arr.addAll(arr2);

 

　　在制定位置插入一个数据【arr.add(Index,Object)】

    arr.add(4,"Garyyy");

 

　　遍历集合

　　//使用for循环遍历
　　for(int i=0;i<arr.size();i++)
　　{
　　　　System.out.println("遍历："+arr.get(i));
　　}

 

 

package com.Gary.arryaylist;

import java.util.ArrayList;

public class ArrayListDemo {

    public static void main(String[] args) {
        // 集合对象
        ArrayList arr = new ArrayList();

        // 往集合中添加一条数据
        arr.add("小明");
        arr.add("小红");
        arr.add("小梁");
        
        //创建多条数据
        ArrayList arr2 = new ArrayList();
        arr2.add("Gary");
        arr2.add("Gary2");

        // 往集合中添加多条数据
        arr.addAll(arr2);
        
        // 使用索引添加对象取得第四号元素Gary
        System.out.println("1："+arr.get(3));
            
        //在制定位置插入一个数据
        arr.add(4,"Garyyy");
        // 使用索引添加对象取得第四号元素Gary
        System.out.println("2："+arr.get(3));

        //使用for循环遍历
        for(int i=0;i<arr.size();i++)
        {
            System.out.println("遍历："+arr.get(i));
        }

    }

}

 

 

三、ArrayList集合中数据的移除和数据访问

　　删除指定数据【arr.remove(Index)】

    arr.remove(1);

 

　　删除arrayList集合中"Gary"【arr.remove(Object)】

　　arr.remove("Gary");

 

　　判断集合是否为空【arr.isEmpty()】

　　判断集合是否包含某个元素arr.contains(Object)

    arr.contains("Gary")

 

 

package com.Gary.arryaylist;

import java.util.ArrayList;

public class ArrayListDemo {

    public static void main(String[] args) {
        // 集合对象
        ArrayList arr = new ArrayList();

        // 往集合中添加一条数据
        arr.add("小明");
        arr.add("小红");
        arr.add("小梁");
        
        //创建多条数据
        ArrayList arr2 = new ArrayList();
        arr2.add("Gary");
        arr2.add("Gary2");

        // 往集合中添加多条数据
        arr.addAll(arr2);
        
        // 使用索引添加对象取得第四号元素Gary
        //System.out.println("1："+arr.get(3));
            
        //在制定位置插入一个数据
        arr.add(4,"Garyyy");
        // 使用索引添加对象取得第四号元素Gary
        //System.out.println("2："+arr.get(3));

        //使用for循环遍历
        //for(int i=0;i<arr.size();i++)
        //{
        //    System.out.println("遍历："+arr.get(i));
        //}

        //删除第一个数据"小明"
        arr.remove(1);
        //删除arrayList集合中"Gary"
        arr.remove("Gary");
        //使用for循环遍历
        for(int i=0;i<arr.size();i++)
        {
            System.out.println("遍历："+arr.get(i));
        }
        
        //判断集合是否为空
        System.out.println("集合是否为空："+arr.isEmpty());
        //判断集合是否包含某个元素
        System.out.println("集合是否包含Gary："+arr.contains("Gary"));    //已经移除
        System.out.println("集合是否包含Gary："+arr.contains("Gary2"));    //存在Gary2
        
        Object[] oArray = arr.toArray();
        for(int i=0;i<oArray.length;i++)
        {
            //使用数值进行遍历
            System.out.println("数据遍历："+oArray[i]);
        }
        
    }

}

 

　　此时arrayList集合中还存在的元素有：小明、小梁、Garyyy、Gary2

 

 

四、使用遍历器和增强版for循环遍历ArrayList集合

 　　创建一个遍历器Iterator

    Iterator iterator = arr.iterator();

 

　　按Index索引下标0开始遍历，遍历Iterator中的元素

    System.out.println(iterator.next());

 

 

package com.Gary.arryaylist;

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

public class ArrayListDemo {

    public static void main(String[] args) {
        // 集合对象
        ArrayList arr = new ArrayList();

        // 往集合中添加一条数据
        arr.add("小明");
        arr.add("小红");
        arr.add("小梁");
        
        //创建多条数据
        ArrayList arr2 = new ArrayList();
        arr2.add("Gary");
        arr2.add("Gary2");

        // 往集合中添加多条数据
        arr.addAll(arr2);
            
        //在制定位置插入一个数据
        arr.add(4,"Garyyy");
        
        //删除第一个数据"小明"
        arr.remove(1);
        //删除arrayList集合中"Gary"
        arr.remove("Gary");
        
        //使用Iterator遍历器进行遍历
        Iterator iterator = arr.iterator();
        //按Index索引下标0开始遍历，遍历三个元素
        System.out.println(iterator.next());
        //System.out.println(iterator.next());
        //System.out.println(iterator.next());
        
        
        while(iterator.hasNext())
        {
            //使用遍历器进行遍历
            System.out.println("Iterator遍历："+iterator.next());
        }
        
        //增强版for循环
        for(Object o:arr)
        {
            System.out.println("增强版for循环："+o);
        }
        
    }

}

 

 

五、关于Vector集合类的使用

　　创建一个Vector集合

    Vector v = new Vector();

 

　　往集合中添加元素【v.add(Object)】

　　v.add("Gary");

 

　　通过索引删除Vector集合中的元素【v.remove(index)】

    v.remove(1);

 

 

package com.Gary;

import java.util.Vector;

public class VectorDemo {

    public static void main(String[] args) {
        Vector v = new Vector();
        
        v.add("Gary");
        v.add("Gary1");
        v.add("Gary2");
        v.add("Gary3");

        for(Object o :v) {
            System.out.println("使用增强for循环："+o);
        }
        
        //得到Vector中的第二个元素
        System.out.println(v.get(1));
        
        //移除第二个元素
        v.remove(1);
        for(Object o:v){
            System.out.println("第二次使用增强for循环："+o);
        }
        
        
    }
    
}

 

 

六、LinkedList集合类的使用

　　LinkedList集合多了两个方法，可以在列表的首位添加元素

　　内部使用引用进行数据的存储

        ll.addFirst();
        ll.addLast();

 

 

package com.Gary;

import java.util.LinkedList;

public class LinkedListDemo {

    public static void main(String[] args) {
        LinkedList ll = new LinkedList();
        
        ll.add(1);
        ll.add(2);
        ll.add(3);
        ll.add(4);
        
        //在列表的首位添加元素
        ll.addFirst(100);
        ll.addLast(200);
        
        for(Object o:ll){
            System.out.println("使用增强for循环："+o);
        }
        
        
        
    }
    
}

 

 

七、集合中泛型的使用

　　直接创建一个新集合时

    ArrayList al = new ArrayList();

 

　　ArrayList创建的是一个Object类型，可以在创建ArrayList后边添加一个泛型

    //泛型 ArrayList中只能存储Int类型
    ArrayList<Integer> al = new ArrayList<Integer>();

 

　　其它集合的泛型

    //ArrayList al = new ArrayList();
    //泛型中不能直接存放基本数据类型->基本类型的刨床类
　　 //数据里边可以存储 引用类型 和 其它类型
        
    //泛型 ArrayList中只能存储Int类型
    ArrayList<Integer> al = new ArrayList<Integer>();
        
    //泛型 Vector中只能存储String类型
    Vector<String> v = new Vector<String>();
        
    //泛型 LinkedList中只能存储字符
    LinkedList<Character> ll = new LinkedList<Character>();

 

package com.Gary;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Vector;

public class Gary {

    public static void main(String[] args){
        //ArrayList al = new ArrayList();
        //泛型中不能直接存放基本数据类型->基本类型的刨床类
        
        //泛型 ArrayList中只能存储Int类型
        ArrayList<Integer> al = new ArrayList<Integer>();
        
        //泛型 Vector中只能存储String类型
        Vector<String> v = new Vector<String>();
        
        //泛型 LinkedList中只能存储字符
        LinkedList<Character> ll = new LinkedList<Character>();
        
    }
    
}

 

 

八、HashSet集合类的使用

　　创建HastSet集合类

    HashSet set = new HashSet();

 

　　HashSet 自动去重、无序

 

package com.Gary;

import java.util.HashSet;

public class HashSetDemo {

    public static void main(String[] args) {
        //ArrayList LinkedList Vector 可以添加重复数据、有序、按照添加顺序排列
        //HashSet 自动去重、无序
        //无法通过索引获取到某个元素
        HashSet set = new HashSet();
        set.add("Gary");
        set.add("Gary1");
        set.add("Gary2");
        set.add("Gary3");
        set.add(1);
        set.add("Gary");
        
        for(Object o : set)
        {
            System.out.println("增强版for循环"+o);
        }
        
        
    }
    
}

 

 

九、TreeSet集合类的使用

　　TreeSet和HashSet区别：

　　TreeSet存放数据是有序的

　　HashSet存放数据是无序的

 

package com.Gary;

import java.util.TreeSet;

public class TreeSetDemo {

    public static void main(String[] args){
        //输出有序的
        TreeSet set = new TreeSet();
        
        set.add("Gary1");
        set.add("Gary2");
        set.add("Gary3");
        set.add("Gary4");
        set.add("Gary5");
        
        for(Object o : set){
            System.out.println("增强for循环："+o);
        }
        
        
    }
    
}

 

 

十、使用集合存储自定义类的类型数据

 　　创建自定义Student学生类，添加两个属性

    private int age;
    private String name;

 

package com.Gary;

public class Student {

    private int age;
    private String name;
    
    public Student(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    
    
}

 

 　　创建一个集合，用于存储Student学生类型

    ArrayList<Student> al = new ArrayList<Student>();

 

 

 

package com.Gary;

import java.util.ArrayList;

public class Gary01 {

    public static void main(String[] args) {
        
        ArrayList<Student> al = new ArrayList<Student>();
        
        Student s = new Student(20,"Gary");
        al.add(s);
        
        for(Student temp : al){
            System.out.println("年龄："+temp.getAge()+" 名字："+temp.getName());
        }
        
    }
    
}

 

 

十一、HashMap集合类的创建和使用

　　HashMap集合以键值对key -- value去存储数据

　　　　所有的key是不可以重复的 -> key重复会照成数据的覆盖

　　　　所有的value是可以重复的　

 

 

package com.Gary;

import java.util.HashMap;

public class HashMapDemo {
    
    public static void main(String[] args){
        
        //HashMap里面保存的是键值对   key - value
        //所有的key不可以重复
        //所有的value不可以重复    
        
        HashMap map = new HashMap();
        
        map.put("Gary", 20);
        map.put("Gary", 21);    //覆盖键值对，如果相同的话，会把之前的值给覆盖掉
        map.put("Gary", 21);
        map.put("Gary2", 22);
        
        System.out.println(map.get("Gary"));
        
        
        for(Object key : map.keySet()) {
            System.out.println("通过键值对去取得值："+key+"---"+map.get(key));
        }
            
            
        
    }
    
    
}