1.
之前我们学过 数组: 数组的特点: 01. 长度一旦被定义,不允许被改变 02. 在内存中开辟一连串连续的空间! 那么现在有一个需求: 让我们定义一个数组 来 保存 新闻信息!!! 问题: 01.如果定义一个数组 长度为50 今天的新闻数量只有10条! 那么有40个空间被浪费掉了! 02.今天的新闻数量只有100条! 那么无法存放多余的50条信息! 在程序的运行过程中,我们不知道需要多少个对象的时候,我们首选集合!!! 集合框架! Vector 线程安全的,但是性能低! List Set Map java中的集合框架是 jdk给我们提供好的一些列接口或者类的集合! 他们都存在于 java.util包中! public interface List<E> extends Collection<E> public interface Set<E> extends Collection<E> public interface Map<K,V> 通过观看底层代码 得知: List Set 接口都 继承了Collection接口! Collection接口中存储的都是不唯一(可以重复),无序的对象! List接口中存储的都是不唯一(可以重复),有序(插入顺序)的对象! 常用的实现类 ArrayList LinkedList Set接口中存储的都是唯一(不可以重复),无序的对象! 常用的实现类 HashSet TreeSet Map是单独的接口! Map接口存储的是一组键值对(key , value)!key是不允许重复的! 常用的实现类 HashMap TreeMap 接口不能被实例化! 所以我们刚才看到的 List Set Map 都应该有对应的实现类! 我们使用的时候肯定是使用实现类!或者使用多态! 父类引用指向子类的对象! 学数组的时候有没有工具类??? Arrays 现在集合中 也有工具类 Collections /** * ArrayList和LinkedList的区别 * ArrayList:采用数组的形式来保存数据!这些数据被放在内存中开辟连续的空间! * 每个数据的位置都有下标! * 比如说: * 现在集合长度为50! 现在想删除下标为2的元素! * 删除之后,底层还要做什么操作? * 下标为2之后的元素都要前移?? * * 现在想在下标为3的位置 新增 元素! * 下标3的元素之后的数据全部后移?? * 所以 新增,删除效率慢! * 因为是数组结构,所以遍历,查询效率高! * * LinkedList:链表式结构!存储在集合中的每个对象都存放在相互独立的空间! * 比如说: * 现在集合长度为50! * 第1个元素记录第2个元素的位置 * 第2个元素记录第3个元素的位置 * 。。。。 * 第49个元素记录第50个元素的位置 * 我们想删除第3个元素! * 只需要让 第2个元素记录第4个元素的位置! * 之后的元素有影响吗? 没有 * * 在第2个元素和第3个元素之间新增一个元素x * 这时候只需要 第2个元素 记录x的位置 * x记录第三个元素的位置 * 新增,删除效率高! * 因为没有下标,所以查询遍历的效率低! * */
2.ArrayList
public class ArrayTest {

    public static void main(String[] args) {

        int nums[] = new int[5];
        nums[0] = 1;
        nums[1] = 1;
        nums[2] = 1;
        nums[3] = 1;
        nums[4] = 1;
        nums[5] = 1; // ArrayIndexOutOfBoundsException

    }

}
ArrayList
import java.util.ArrayList;

public class ArrayListTest {

    public static void main(String[] args) {
        /**
         * 在程序运行过程中,不确定有多少个对象  加入到 集合中!
         * 使用集合框架!
         * 现在 我们想 新增   LinkedList
         * 现在 我们想 查询   ArrayList
         * 上述的两个类  都是  List接口的 实现类!
         * 
         * 01. ArrayList 底层是实现了一个可变长度(自动扩容)的数组!
         *     在内存中也是分配连续的空间!
         *     遍历元素和随机访问元素的时候 性能高!  因为有下标!
         */

        // 01创建一个ArrayList集合
        ArrayList list = new ArrayList();
        /**
         *  02. 向集合中增加元素
         *    为什么可以存放这么多数据类型
         *    因为底层就是一个Object[]数组   默认的初始长度=10
         *    Object 所有类的父类,所以可以存放任何类型!
         *  
         */
        list.add(1);
        list.add("2");
        list.add(12.5);
        list.add('5');
        list.add('1');
        list.add(null);
        list.add(7);
        list.add(8);
        list.add(9);
        list.add(10);
        list.add(11); // 自动扩充 原来长度的1.5倍
        // 03.输出集合的长度 实际使用的位置个数
        System.out.println(list.size());
        // 04. 查询集合中下标是3 的元素
        System.out.println("集合中下标是3 的元素:" + list.get(3));
        // 05. 删除下标为5的元素
        list.remove(5);
        System.out.println("删除元素之后的长度:" + list.size());
        // 06.查询集合中是否包含某个元素
        System.out.println("集合中是否包含12.5:" + list.contains(12.5));
    }
}
ArrayListTest

3.LinkedList

import java.util.LinkedList;

public class LinkedListTest {

    public static void main(String[] args) {
        /**
         * 02.LinkedList :采用的是链表式存储结构!  插入和删除的效率高!
         *    
         *    谁能告诉我???
         *    为什么不使用 
         *   List list = new LinkedList();   父类的引用指向了子类的对象!
         *    
         *   LinkedList list=  new LinkedList();  使用这种方式!
         *   
         *    List  和 LinkedList 什么关系?
         *      001.LinkedList继承了List!
         *    List接口中有的方法LinkedList有吗?  
         *      002. 有
         *    LinkedList中有特有的方法,  List接口中有吗?  !!!!
         *      003. 没有!
         *     
         */
        // 创建集合
        LinkedList list = new LinkedList();
        // 创建新闻对象
        News news1 = new News(1, "新闻1");
        News news2 = new News(2, "新闻2");
        News news3 = new News(3, "新闻3");
        News news4 = new News(4, "新闻4");

        // 集合中保存新闻信息
        list.add(news1);
        list.addFirst(news2);
        list.add(news3);
        list.addFirst(news4);

        for (Object object : list) {
            News news = (News) object;
            System.out.println(news);
        }

        // 删除最后一个对象
        list.removeLast();
        System.out.println("*********************");
        for (Object object : list) {
            News news = (News) object;
            System.out.println(news);
        }
        // 查询某个元素在集合中的位置
        System.out.println("news4在集合中的位置:" + list.indexOf(news4));

    }
}
LinkedListTest

4.Iterator

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

/*
 * 新闻实体类
 */
public class News {

    private int id; // 新闻编号
    private String title; // 新闻标题

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public News(int id, String title) {
        super();
        this.id = id;
        this.title = title;
    }

    public News() {
        super();
    }

    @Override
    public String toString() {
        return "News [id=" + id + ", title=" + title + "]";
    }

    public static void main(String[] args) {
        // 创建一个集合
        ArrayList list = new ArrayList();
        // 创建新闻对象
        News news1 = new News(1, "新闻1");
        News news2 = new News(2, "新闻2");
        News news3 = new News(3, "新闻3");
        News news4 = new News(4, "新闻4");

        // 集合中保存新闻信息
        list.add(news1);
        list.add(news2);
        list.add(news3);
        list.add(news4);
        // list.add("aaaaaa");ClassCastException 类型转换

        // 01.第1种方式 遍历 for循环
        for (int i = 0; i < list.size(); i++) {
            News news = (News) list.get(i); // 必须向下转型
            System.out.println(news);
        }
        System.out.println("*****************************");
        // 02.第2种方式 遍历 for增强循环
        for (Object n : list) {
            News news = (News) n; // 必须向下转型
            System.out.println(news);
        }
        System.out.println("*****************************");
        /**
         *  03.第3种方式 遍历 iterator 迭代器循环
         *  
         *  001.hasNext() :判断我们的集合中是否还有元素
         *  002.next():获取集合中的下一个元素
         *  003.remove():删除元素
         */
        // 清空整个集合
        list.clear(); // 底层的数组 长度还是之前的长度!
        // 判断集合是否为空
        System.out.println("集合是否为空:" + list.isEmpty());
        Iterator it = list.iterator();
        while (it.hasNext()) {
            News news = (News) it.next();// 获取元素
            System.out.println(news);
        }

    }

}
Iterator

5.Set

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

public class SetTest {

    public static void main(String[] args) {
        /**
         * Set :
         *   01.存储的是唯一(不能重复) 无序的数据!
         *   02.HashSet是常用的实现类
         *   03.存放的是对象的引用
         */

        Set set = new HashSet();
        set.add(1);
        set.add("1");
        set.add('1');
        set.add(null);
        System.out.println(set.size()); // 输出集合的大小 4

        Set set2 = new HashSet();
        set2.add(1);
        set2.add(1);
        set2.add(1);
        System.out.println(set2.size()); // 输出集合的大小 1

        /**
         *  通过观看底层代码得知:                                        
            private transient HashMap<E,Object> map; 
             public boolean add(E e) {               
                  return map.put(e, PRESENT)==null;  
              }  
         01.HashSet    类中 有一个属性是 map  ,值类型是 HashMap
         02.我们在使用add(e) ,其实是调用了map.put(e,PRESENT)
              把e当成了map的key值!
              因为Map的key是唯一的! 所以我们的hashSet存储的也是唯一的!
         03.那么怎么知道    map中的key是唯一的呢? 看hashMap的put()  
         
           String的底层 是 char类型的数组!
           怎么比较两个值是否一致?  把char数组中的每一个元素都比较,全相等  才相等!
           
           所以hashMap在添加数据的时候
           01.先进行hash运算
           02.把计算的值当成数组中的下标
           03.判断下标指向的数组元素是否为空,如果为空 直接 添加数据
           04.如果不为空
                   依次查询entry中的所有元素
           05.判断key是否相等
                001.e.hash == hash
                002.(k = e.key) == key || key.equals(k)
              如果相等  直接覆盖
           不相等 通过next的变量 将值 新增到entry!  
           
           
           
           
           HashSet 和 TreeSet的区别
           
          01. HashSet底层是哈希表实现的!
              TreeSet底层是二叉树实现的!
          02. HashSet存放的数据是无序的!
              TreeSet存放的数据是有序的!
          03. HashSet可以存放 null!但是只能是一个null!
              TreeSet不可以存放null!
          04. HashSet底层是由HashMap实现! 
              TreeSet底层是由TreeMap实现! 
          05. HashSet是线程不安全的! 单线程是安全!
              TreeSet是线程安全的!   
           
         */

    }

}
set
import java.util.HashSet;
import java.util.Set;

import org.junit.Test;

public class StringTest {

    public static void main(String[] args) {

        Set set = new HashSet();
        set.add("1");
        set.add(new String("1"));
        set.add(new String("1"));
        System.out.println(set.size());

        // 疑问? 为什么 两次new 确是一样的
        String a = new String("1");
        String b = new String("1");
        String c = "1";
        System.out.println(a == b);
        System.out.println(a == c);
        // 内容相同的String对象 hashCode是一致的!
        System.out.println(a.hashCode() == b.hashCode());
        System.out.println(a.hashCode() == c.hashCode());
    }

    @Test
    public void test1() {
        String a = new String("1");
        /**
         * 01.首先在栈中开辟空间存储a
         * 02.去常量池中查询有没有 字符串1 没有就在常量池中创建字符串1
         * 03.再去堆中创建一个字符串1
         * 04.a指向堆中的字符串1
         */
        String b = "1";
        /**
         * 01.首先在栈中开辟空间存储b
         * 02.去常量池中查询有没有 字符串1   有
         * 03.b指向常量池中的字符串1
         */
        System.out.println(a == b); // false
    }

    @Test
    public void test2() {
        String a = "abc";
        String b = "abc";
        System.out.println(a == b); // true
        System.out.println(a == "abc"); // true
    }

    @Test
    public void test3() {
        String a = "abc";
        String b = "a";
        String c = "bc";
        System.out.println(a == ("a" + "bc")); // true
        /**
         * b  和  c  都是变量!!!!!!
         * 在运行期间可以改变的量!
         */
        System.out.println(a == (b + c)); // false
    }

    @Test
    public void test4() {
        String a = "abc";
        final String b = "a";
        final String c = "bc";
        System.out.println(a == ("a" + "bc")); // true
        /**
         * 在编译期间因为b  和  c  都是常量
         * 所以就把b+c="abc"
         */
        System.out.println(a == (b + c)); // true
    }
}
HashSet

6.Map

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

import org.apache.log4j.Logger;
import org.junit.Test;

import cn.bdqn.listtest.News;

public class MapTest {

    public static void main(String[] args) {

        /**
         * Map: 是一个key  value 键值对的集合!
         *       key是唯一的!
         * 
         * 存放值:
         *  put(key,value)
         *  
         * 取值
         *   get(key)    根据key获取value
         */

        Map map = new HashMap();
        map.put(1, "haha1");
        map.put("1", "haha2");
        map.put(new String("1"), "haha3");
        System.out.println(map.size());
    }

    @Test
    public void test1() {
        Map map = new HashMap();
        map.put("news1", new News(1, "新闻标题1"));
        map.put("news2", new News(2, "新闻标题2"));
        map.put("news3", new News(3, "新闻标题3"));
        /**
         * 我们想获取value的值   只能通过key
         * key是一个集合 就是set
         */
        Set keySet = map.keySet();
        for (Object o : keySet) {
            System.out.println(o); // key
        }
        /**
         * 获取所有value的集合
         */
        Collection values = map.values();
        for (Object o : values) {
            System.out.println(o); // value
        }

        System.out.println("****************************");

        // 直接使用一个循环 获取value
        for (Object key : keySet) {
            News news = (News) map.get(key); // 根据key获取value
            System.out.println(news);
        }
        System.out.println("****************************");
        Iterator it = keySet.iterator();
        while (it.hasNext()) {
            News news = (News) map.get(it.next());
            System.out.println(news);
        }

        System.out.println("************ EntrySet()****************");

        /**
         * 强烈推荐使用 EntrySet()
         * 可以在获取key的同时获取value!不需要两次查询
         */
        Iterator it1 = map.entrySet().iterator();
        while (it1.hasNext()) {
            Entry entry = (Entry) it1.next();
            System.out.println("map中的key:" + entry.getKey());
            System.out.println("map中的value:" + entry.getValue());
        }
    }

    Logger log = Logger.getLogger(MapTest.class);

    @Test
    public void test2() {
        Map map = new HashMap();
        for (int i = 1; i <= 200000; i++) {
            map.put(i, "" + i);
        }
        System.out.println("map的大小:" + map.size());

        // 获取当前的毫秒数 从1970年1月1日到现在的毫秒
        long start = System.currentTimeMillis();
        Set keySet = map.keySet();
        for (Object key : keySet) {
            System.out.println(map.get(key));
        }
        long end = System.currentTimeMillis();
        log.debug("使用for循环的用时:" + (end - start));

        start = System.currentTimeMillis();
        Iterator iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Entry entry = (Entry) iterator.next();
            System.out.println(entry.getValue());
        }
        end = System.currentTimeMillis();
        log.debug("使用Iterator循环的用时:" + (end - start));
    }

    /***
     * 
     *  HashMap 和  HashTable 的区别
     *   01.HashMap    线程不安全 但是性能高
     *      HashTable  线程   安全 但是性能低
     *   02.HashMap 底层是哈希表实现的,每一个元素一个key -value键值对!
     *        key和value都可以为null!
     *      HashTable的key和value都不可以为null!
     *   03.历史版本不同
     *      HashMap    1.2
     *      HashTable  1.0
     */
}
MapTest

7.泛型

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

import cn.bdqn.listtest.News;

public class MyTest {

    @Test
    public void test01() {
        ArrayList list = new ArrayList();
        // list中可以存放什么类型! Object 所有类型
        list.add(1);
        list.add("1");
        list.add(new Date());
        /**
         *  我们怎么去遍历这些类型的数据
         *  01.集合中的数据不是相同类型
         *  02.不能按照一种方式去遍历
         */

        Set set = new HashSet();
        set.add(1);
        set.add("1");
        set.add(new Date());

        Map map = new HashMap();
        map.put(1, "1");
        map.put("1", "haha");
        map.put("2", new Date());

        /**
         * 上面三个 集合 
         * 01.因为我们没有在创建集合的同时 规定集合中可以存放什么类型的数据
         * 02.所以集合中可以存放Object类型的数据
         * 03.导致后续操作很麻烦
         * 04.如果我们想获取集合中的某个元素,需要使用get()
         * 05.但是get()返回值是 object类型
         * 06.需要向下转型,转换成指定的类型,之后才能操作!
         * 
         * 
         * 有没有一种方式,
         * 01.可以在创建集合的时候,规定集合中只能存放什么类型
         * 02.能不能在get()不进行向下转型!!!
         * 
         * 能!
         * 使用泛型!
         * 泛型集合:  创建集合的时候,规定集合中存放数据的类型!
         * 
         */

    }

    /**
     *  使用泛型集合   方便+安全
     *  <> 就是集合中指定的元素类型!
     *  
     *  泛型集合中 不允许 存放基本数据类型的元素!
     *  如果想存放基本数据类型!
     *  必须使用基本数据类型对应的 包装类
     *  
     *  java中有8种基本数据类型,使用ctrl+鼠标左键   点不进去! 说明不是类
     *   
     *  那就有8个对应的包装类!
     *  byte    Byte
     *  short   Short
     *  int     Integer        
     *  long    Long
     *  float   Float
     *  double  Double
     *  
     *  boolean  Boolean
     *  char     Character
     *  
     */
    @Test
    public void test02() {
        ArrayList<String> list = new ArrayList<String>();
        // 说明list集合中只能存放String类型的数据
        // list.add(new Date()); 编译报错
        ArrayList<News> list2 = new ArrayList<News>();
        // list2集合中 只能存放 News 对象!
        ArrayList<Double> list3 = new ArrayList<Double>();
        list3.add(2.0);

        double a = 2;
        // Double b = 2; 编译报错
    }

    @Test
    public void test03() {
        /**
         * 创建了一个map泛型集合!
         * 集合的key只能是String类型
         * value只能是News类型!
         * 
         * map.put(1,"1"); 错误
         * map.put("1","1"); 错误
         * map.put("1",new News());
         */
        Map<String, News> map = new HashMap<>();
        News news1 = new News(1, "新闻1");
        News news2 = new News(2, "新闻2");
        News news3 = new News(3, "新闻3");
        map.put("a", news1);
        map.put("b", news2);
        map.put("c", news3);

        // 遍历出来所有的新闻信息
        Iterator<Entry<String, News>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Entry<String, News> entry = iterator.next();
            // System.out.println(entry.getKey()); 获取所有的key
            News news = entry.getValue(); // 获取所有的value
            System.out.println(news);
        }

    }
}
泛型

 

posted on 2017-09-07 16:31  我可不是隔壁的老王  阅读(160)  评论(0编辑  收藏  举报