关于JAVA学习_集合

集合:
* 1.存储多个对象，数组、集合
* 2.数组存储对象特点：Student[] stu=new Student[10];
*       一旦创建长度不可变
* 3.集合两大体系:collection和map
* collection接口
*           --list
*           有序的,可重复的
*                 ArraryList:底层就是数组 查询速度快,主要实现类
*                 LinkedList:增删改速度快
*         --set接口
*            无序的,不可重复的
*             HashSet

collection代码案例:

package list;

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

import org.junit.Test;

/**
 * 集合:
 * 1.存储多个对象，数组、集合
 * 2.数组存储对象特点：Student[] stu=new Student[10];
 *    一旦创建长度不可变
 * 3.集合两大体系:collection和map
 *       collection接口
 *          --list
 *              有序的,可重复的
 *              ArraryList:底层就是数组 查询速度快,主要实现类
 *              LinkedList:增删改速度快
 *          --set接口
 *              无序的,不可重复的
 *              HashSet
 * 
 *
 */
public class TestCollection {
        @Test
        public void test(){
            Collection coll=new ArrayList();
            //1.size();获取集合元素个数
            System.out.println(coll.size());
            //add(object obj):添加一个对象
            coll.add(1);
            coll.add(17.0);
            coll.add("哈哈");
            coll.add(new Date());
            coll.add("哈哈");
            System.out.println(coll.size());
            //3.addAll(collection c):把集合元素从一个添加到另一个
            //4.isEmpty(): 判断一个集合是否为空,空返回true
            System.out.println(coll.isEmpty());
            //5.clear();清除集合中的元素
            //System.out.println(coll.isEmpty());
            //6.remove(object o):删除集合中的元素
            //coll.remove(1);
            System.out.println(coll.remove(1));
            //7.removeAll(collection c):从当前集合中删除另一集合中所有元素
            //8.contains(object o):判断当前集合是否包含集合o
            //9.toArray():把集合转成一个数组
            Object [] obs=coll.toArray();
            for(Object obj:obs){
                System.out.println(obj);
            }
            
        }
        
        @Test
        public void test1(){
            Collection coll = new ArrayList();
            coll.add("韩信");
            coll.add("赵云");
            coll.add("李白");
            coll.add("玄策");
            
            //遍历
            //迭代 返回一个iterator接口
            Iterator i=coll.iterator();
            while(i.hasNext()){  //判断当前元素下面有没有下一个元素
                System.out.println(i.next());//指向下一个元素
            }
            //foreach
            for (Object o:coll) {
                System.out.println(o);
            }
        }
    
    
}

List接口代码案例:

package list;

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

import org.junit.Test;

public class TestList {
    @Test
    public void test(){
        
        List list=new ArrayList();
        //添加元素
        list.add("123");
        list.add(12);
        list.add(1,"添加");  //指定位置
        System.out.println(list);
        
        //根据索引查询
        System.out.println(list.get(1));
        
    }
    @Test
    public void test1(){
        List list=new ArrayList();
        list.add("孙尚香");
        list.add("孙悟空");
        list.add("猪八戒");
        list.add("张磊");
        
        //遍历
        //第一种for循环
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        
        //第二种foreach
        for(Object o:list){
            System.out.println(o);
        }
        //第三种 迭代
        Iterator i=list.iterator();
        while(i.hasNext()){  //判断当前元素下面有没有下一个元素
            System.out.println(i.next());//指向下一个元素
        }
    }
}

set接口代码案例:

package list;

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

import org.xml.sax.HandlerBase;

/**
 * set:无序的,不可重复的
 *   无序:不是随机,值得是元素在底层存储的位置是无序的
 *   不可重复:在set添加相同元素时,后面的无法添加
 *   set没有自定义方法
 * @author ASUS
 *
 */
public class TextSet {

    public static void main(String[] args) {
        Set set=new HashSet();
        System.out.println(set.size());
    //添加
        set.add("张磊");
        set.add(123);
        set.add("12.3");
        set.add(123);
        System.out.println(set);
        String str=new String("李四");
        set.add(str);
        System.out.println(str.hashCode());
        
        //遍历set
        //第一中:foreach
        for(Object o:set){
            System.out.println(o);
        }
        //第二种:迭代器
        Iterator i=set.iterator();
        while(i.hasNext()){
            System.out.println(i.next());
        }
        
    }

}

Set和List的区别

• 1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。

• 2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。

• 3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

map接口代码案例:

package map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

/**
 * map：以key-value的形式进行存储，主要实现类HashMap()
 *
 */

public class TextMap {
    
    @Test
    public  void test(){
//        Object put(Object key,Object value):添加元素到map
//        Object remove(Object key)：根据key删除对应的元素
//        void putAll(Map t)
//        void clear()：清除
        
        Map map=new HashMap();
        //1.添加
        map.put("1", "张三");
        map.put(2, "李四");
        map.put(5, 12.3);
        map.put("123", 123);
        /**
         * key是通过set存储的，不可重复，无序，value是通过collection进行存储的，可重复。
         * key+value等于一个entry，所entry同等于set，不可重复
         * 如果添加的时候出现重复，后面的把前面的覆盖了
         */
        map.put(5, "王五");
        System.out.println(map);
        System.out.println(map.size());
        map.remove(2);
        System.out.println(map);
        
//        Object get(Object key):根据key查询对应的value
//        boolean containsKey(Object key):判断当前map是否包含指定的key
//        boolean containsValue(Object value):判断当前map是否包含指定的value
//        int size()
//        boolean isEmpty()
//        boolean equals(Object obj)
        
        System.out.println(map.get(5));
        System.out.println(map.containsKey(5));
        System.out.println(map.containsValue("王五"));

    }
    
    @Test
    public void test1(){
        Map map=new HashMap();
        //1.添加
        map.put("1", "张三");
        map.put(2, "李四");
        map.put(5, 12.3);
        map.put("123", 123);
        
//        Set keySet():遍历所有的key
//        Collection values():遍历所有的value
//        Set entrySet():遍历所有的entry
        
        System.out.println("==============遍历所有的key");
        Set set=map.keySet();
        for(Object o:set){
            System.out.println(o);
        }
        
        System.out.println("============遍历所有的value");
        Collection coll=map.values();
        for(Object o:coll)
        System.out.println(o);
        
        //遍历所有的key和value   key:value
        System.out.println("================");
        Set set1=map.keySet();
        for(Object o:set1){
            System.out.println(o+":"+map.get(o));
        }
        
        System.out.println("=============");
        Set set2=map.entrySet();
        for(Object o:set2){
            //把o转成entry
            Entry entry=(Entry)o;
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }

}

泛型:(后续详细学习)

package map;

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

/**
 * 泛型:指定集合只能添加什么类型的数据
 * @author ASUS
 *
 */
public class Test {

    @org.junit.Test
    public void test(){
        List<Integer> list=new ArrayList<Integer>();
        list.add(90);
        list.add(80);
        list.add(99);
        list.add(90);
        
        for(int i=0;i<list.size();i++){
            int score=list.get(i);
            System.out.println(score);
        }
        
    }
}

如何使用迭代器

通常情况下，你会希望遍历一个集合中的元素。例如，显示集合中的每个元素。

一般遍历数组都是采用for循环或者增强for，这两个方法也可以用在集合框架，但是还有一种方法是采用迭代器遍历集合框架，它是一个对象，实现了Iterator 接口或 ListIterator接口。

迭代器，使你能够通过循环来得到或删除集合的元素。ListIterator 继承了 Iterator，以允许双向遍历列表和修改元素。

 更多:https://www.runoob.com/java/java-collections.html