java高级⑴

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);
        }

    }
}

泛型