数组

基础数组

  1. 声明和创建 ``` //声明 int[] arr; int arr[];

//创建 new int[10];

// 声明和创建 int[] arr = new int[10]; String[] names = new String[10];

//不使用new关键字也可以创建数组 初始化数组 int[] a = {1,2,3,4,5}; String[] names = {“John”,”kobe”,”James”};

  2. 2. 迭代数组

// array.length 循环 for(int i=0;i<arr.length;i++){ System.out.println(arr[i]) }

// for-each 循环 for (int i : arr) { System.out.println(i); }

  1. ## java.util.Arrays类
  2. Arrays工具类，提供了操作数组的一系列静态方法，下表显示了它的一些方法。<br />![EBhBcj](https://cdn.jsdelivr.net/gh/Flionay/pic_bed@master/Upic/202106/EBhBcj.png)
  3. # 集合框架
  4. 集合是集中存放其他对象的一个对象，集合也称为容器，它提供存储，检索和操作其元素的方法。位于`java`的`util`包中。<br />**为什么使用集合框架？**数组缺乏快速开发应用程序所需的灵活性，例如数组不能改变大小，而且数组除了下标无法键值对查询数据。<br />`Java`集合框架的体系结构：<br />![集合框架](https://cdn.jsdelivr.net/gh/Flionay/pic_bed@master/Upic/202106/%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6.png)<br />浅绿色表示接口，蓝色为具体实现类。<br />区分`Collection`和`Collections`，它们是完全不同的东西。`Collection`是一个接口，而`Collections`是`Java`提供的一个操作 `Set`、`List` 和 `Map` 等集合的工具类。`Collections` 类提供了许多操作集合的静态方法，借助这些静态方法可以实现集合元素的排序、查找替换和复制等操作。<br />`Collection` 接口存储一组不唯一，无序的对象。<br />`List`存储不唯一，有序。`Set`唯一，无序。`Map`存储一组键值对，提供`key`到`value`的映射。
  5. ## ArrayList
  6. arraylist实现了可变长度的数组。在内存中分配连续的空间，**遍历**元素和**随机访问**元素的效率比较高。

/ 新闻管理系统 可以存储各类新闻标题（ID，名称，创建者） 可以获取标题数量 可以逐条打印每条新闻的标题 /

public class NewsTitle{ private int id; private String title; private String author;

  1. public NewsTitle(){}
  3. public NewsTitle(int id, String title, String author){
  4.     this.id = id;
  5.     this.author = author;
  6.     this.title = title;
  7. }
  9. public int getId() {
  10.     return id;
  11. }
  13. public String getAuthor() {
  14.     return author;
  15. }
  17. public String getTitle() {
  18.     return title;
  19. }
  21. public void setAuthor(String author) {
  22.     this.author = author;
  23. }
  25. public void setId(int id) {
  26.     this.id = id;
  27. }
  29. public void setTitle(String title) {
  30.     this.title = title;
  31. }

}

  1. ```
  2. import java.util.ArrayList;
  4. public class NewsMgr {
  5.     public static void main(String[] args) {
  6.         NewsTitle title1 = new NewsTitle(1,"北京热门-长城","xx1");
  7.         NewsTitle title2 = new NewsTitle(2,"北京热门-故宫","xx1");
  8.         NewsTitle title3 = new NewsTitle(3,"北京热门-颐和园","xx1");
  9.         NewsTitle title4 = new NewsTitle(4,"北京热门-天安门","xx1");
  10.         NewsTitle title5 = new NewsTitle(5,"北京热门-天坛","xx1");
  12.         ArrayList list = new ArrayList();
  13.         list.add(title1);
  14.         list.add(title2);
  15.         list.add(title3);
  16.         list.add(title4);
  17.         list.add(title5);
  19.         //获取新闻标题的总数
  20.         // ArrayList size() 等同于 数组的length属性
  21.         System.out.println("新闻标题共有"+list.size()+"条");
  23.         // 逐条打印
  24.         for (int i = 0; i < list.size(); i++) {
  25.             NewsTitle obj = (NewsTitle) list.get(i); //等同于数组的 [i] 索引
  26.             System.out.println(obj.getTitle());
  27.         }
  28.         System.out.println("=========");
  29.         for (Object obj:list){
  30.             NewsTitle news = (NewsTitle)obj;
  31.             System.out.println(news.getTitle());
  32.         }
  34.         System.out.println("==========");
  35.         list.remove(title2);
  36.         System.out.println(list.contains(title2));
  37.         // add() size() contains() remove() 是Collection接口的通用方法
  38.         //常用的方法还有 clear() isEmpty() iterator() toArray()
  40.         System.out.println(list.isEmpty());
  41.         list.clear();
  42.         System.out.println(list.isEmpty());
  43.     }
  44. }

add() size() contains() remove() 是Collection接口的通用方法
常用的方法还有clear() isEmpty() iterator()`` toArray()等。

LinkedList

LinkedList采用链表（不是下标，指向型）存储方式，插入、删除元素的效率比较高。不是连续存放。
image-20210627172812423

  1. import java.util.LinkedList;
  3. public class NewsMgr {
  4.     public static void main(String[] args) {
  5.         NewsTitle title1 = new NewsTitle(1,"北京热门-长城","xx1");
  6.         NewsTitle title2 = new NewsTitle(2,"北京热门-故宫","xx1");
  7.         NewsTitle title3 = new NewsTitle(3,"北京热门-颐和园","xx1");
  8.         NewsTitle title4 = new NewsTitle(4,"北京热门-天安门","xx1");
  9.         NewsTitle title5 = new NewsTitle(5,"北京热门-天坛","xx1");
  11.         LinkedList list = new LinkedList();
  12.         list.add(title1);
  13.         list.add(title2);
  14.         list.add(title3);
  15.         list.add(title4);
  16.         list.add(title5);
  17.         NewsTitle title6 = new NewsTitle(6,"北京热门-国家博物馆","xx1");
  19.         list.addFirst(title6);
  20.         System.out.println("新闻标题共有"+list.size()+"条");
  22.         for (Object obj : list) {
  23.             NewsTitle ob = (NewsTitle) obj;
  24.             System.out.println(ob.getTitle());
  25.         }
  26.         // 获取头条和最后的新闻
  27.         NewsTitle titleFirst = (NewsTitle) list.getFirst();
  28.         System.out.println("第一条新闻: "+titleFirst.getTitle());
  30.         NewsTitle titleLast= (NewsTitle) list.getLast();
  31.         System.out.println("最后一条新闻: "+titleLast.getTitle());
  33.         list.removeLast();
  34.         NewsTitle titleLast1= (NewsTitle) list.getLast();
  35.         System.out.println("最后一条新闻: "+titleLast1.getTitle());
  38.     }
  39. }

Set

image-20210627190546395

  1. import java.util.HashSet;
  3. public class NewsMgr {
  4.     public static void main(String[] args) {
  5.         NewsTitle title1 = new NewsTitle(1,"北京热门-长城","xx1");
  6.         NewsTitle title2 = new NewsTitle(2,"北京热门-故宫","xx1");
  7.         NewsTitle title3 = new NewsTitle(3,"北京热门-颐和园","xx1");
  8.         NewsTitle title4 = new NewsTitle(4,"北京热门-天安门","xx1");
  9.         NewsTitle title5 = new NewsTitle(5,"北京热门-天坛","xx1");
  11.         HashSet set = new HashSet();
  12.         set.add(title1);
  13.         set.add(title2);
  14.         set.add(title3);
  15.         set.add(title4);
  16.         set.add(title5);
  18.         System.out.println(set.size());
  19.         // 乱序  没有get方法
  20.         for (Object obj : set) {
  21.             NewsTitle news = (NewsTitle) obj;
  22.             System.out.println(news.getTitle());
  23.         }
  25.     }
  26. }

HashMap

hashmap和Treemap属于Map接口，而map接口与Collection接口属于并列关系。
所以HashMap和TreeMap与Collection集合框架接口没有继承关系。

  1. import java.util.HashMap;
  2. import java.util.Iterator;
  3. import java.util.Map;
  4. import java.util.Set;
  6. public class ContryInfo {
  7.     public static void main(String[] args) {
  8.         HashMap map = new HashMap();
  9.         map.put("China","中国");
  10.         map.put("USA","美国");
  11.         map.put("Japan","日本");
  12.         map.put("Italy","意大利");
  13.         map.put("Koera","韩国");
  16.         System.out.println(map.size());
  17.         // 返回是object 需要一个强制类型转换
  18.         String contry = (String) map.get("Italy");
  19.         System.out.println(contry);
  21.         System.out.println(map.keySet());
  22.         System.out.println(map.containsKey("Australia"));
  23.         if (map.containsKey("USA")) {
  24.             map.remove("USA");
  25.         }
  27.         // 遍历一
  28.         Set keyss = map.keySet();
  29.         Iterator keys = keyss.iterator();
  30.         while(keys.hasNext()){
  31.             String value = (String) map.get(keys.next());
  32.             System.out.println(value);
  33.         }
  34.         System.out.println("===================");
  35.         //遍历二
  36.         for (Object obj : keyss) {
  37.             String value = (String) map.get(obj);
  38.             System.out.println(value);
  39.         }
  41.         //遍历三
  42.         System.out.println("=================");
  43.         Set items = map.entrySet();
  44.         for (Object obj : items) {
  45.             // item是键值对 它属于Map.entry类型
  46.             Map.Entry item = (Map.Entry) obj;
  47.             System.out.println("("+item.getKey()+","+item.getValue()+")");
  48. //            System.out.println(item.getValue());
  49.         }
  52.     }
  53. }

泛型

作用：
上面我们学习的collection接口几个实现类HashMap或者ArrayList linkedlist等它们的get方法等获取出来的类型都是object类型，我们需要进行一个强制类型转换。
强制类型转换容易出现一些问题。所以JDK5之后增加了一个非常具有安全性和稳定性的特性——泛型。避免了一些类型转换的问题。

  1. ArrayList<String> strList = new ArrayList<String>();
  1. import java.util.LinkedList;
  3. public class NewsMgr {
  4.     public static void main(String[] args) {
  5.         NewsTitle title1 = new NewsTitle(1,"北京热门-长城","xx1");
  6.         NewsTitle title2 = new NewsTitle(2,"北京热门-故宫","xx1");
  7.         NewsTitle title3 = new NewsTitle(3,"北京热门-颐和园","xx1");
  8.         NewsTitle title4 = new NewsTitle(4,"北京热门-天安门","xx1");
  9.         NewsTitle title5 = new NewsTitle(5,"北京热门-天坛","xx1");
  11.         // 泛型
  12.         LinkedList<NewsTitle> list = new LinkedList<NewsTitle>();
  13.         list.add(title1);
  14.         list.add(title2);
  15.         list.add(title3);
  16.         list.add(title4);
  17.         list.add(title5);
  18.         NewsTitle title6 = new NewsTitle(6,"北京热门-国家博物馆","xx1");
  20.         list.addFirst(title6);
  21.         System.out.println("新闻标题共有"+list.size()+"条");
  23.         for (NewsTitle obj : list) {   //返回类型即为NewsTitle
  24. //            NewsTitle ob = (NewsTitle) obj;
  25.             System.out.println(obj.getTitle());
  26.         }
  27.         //泛型 获取头天新闻
  28.         String titleFirst = list.getFirst().getTitle();
  29.         System.out.println("第一条新闻: "+titleFirst);
  31. //        // 获取头条新闻
  32. //        NewsTitle titleFirst = (NewsTitle) list.getFirst();
  33. //        System.out.println("第一条新闻: "+titleFirst.getTitle());
  35.     }
  36. }
  1. Map<String,String> conntry = new HashMap<String,String>();

type argument cannot be of primitive type，类型参数不能是原始数据类型，List会报错，该使用封装类型的地方使用了原始数据类型
但可以改成List list = new ArrayList();
调用时list[0]显示Integer类型，但list.get(0)就是int类型
Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。比如:Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类,常见的原始与对应的封装类如下:

| 原始类型 | 封装类 | | —- | —- |

| boolean | Boolean |

| char | Character |

| byte | Byte |

| short | Short |

| int | Integer |

| long | Long |

| float | Float |

| double | Double |

Collections类

作用和常用方法：提供了一些算法实现的工具类，常用静态方法如排序，查找，最大最小值，反转元素顺序等。

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.List;
  5. public class Test01 {
  6.     public static void main(String[] args) {
  7.         List<String> list = new ArrayList<String>();
  8.         list.add("a1");
  9.         list.add("a2");
  11.         List<Integer>list2 = new ArrayList<Integer>();
  12.         list2.add(2);
  13.         list2.add(3);
  14.         list2.add(15);
  15.         list2.add(10);
  18.         System.out.println("====================");
  20.         // 遍历
  21.         for (Integer i : list2) {
  22.             System.out.println(i);
  23.         }
  24.         //排序
  25.         Collections.sort(list2);
  26.         Collections.reverse(list2);
  27.         System.out.println("====================");
  28.         for (Integer i : list2) {
  29.             System.out.println(i);
  30.         }
  31.         System.out.println("====================");
  32.         // 最大最小
  33.         System.out.println(Collections.max(list2));
  34.         System.out.println(Collections.min(list2));
  36.         System.out.println("====================");
  37.         // 指定元素
  38.         System.out.println(Collections.binarySearch(list2,3));
  41.     }
  42. }

Collections 对自定义类排序

直接用Collections的sort方法肯定是不行的，因为它不知道用什么规则进行排序。
这时需要我们在类中自定义排序规则，首先需要实现Comparable接口，然后重写compareTo()方法。以上文所用的NewsTitle为例：

  1. package com.collection.arraylist;
  2. public class NewsTitle implements Comparable{
  3.     private int id;
  4.     private String title;
  5.     private String author;
  7.     public NewsTitle(){}
  9.     public NewsTitle(int id, String title, String author){
  10.         this.id = id;
  11.         this.author = author;
  12.         this.title = title;
  13.     }
  15.     // get - set 方法省略
  17.     // 重写方法，定义新闻类的比较规则，根据id进行比较
  18.     // 比较对象，当前新闻对象 和 object比
  19.     @Override
  20.     public int compareTo(Object o) {
  21.         NewsTitle news = (NewsTitle) o;
  22.         if(this.id==news.id){
  23.             return 0;
  24.         }else if(this.id>news.id){
  25.             return 1;
  26.         }else{
  27.             return -1;
  28.         }
  29.     }
  30. }
  1. package com.collection.collections;
  2. import com.collection.arraylist.NewsTitle;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  7. public class Test02 {
  8.     public static void main(String[] args) {
  9.         List<NewsTitle> list = new ArrayList<NewsTitle>();
  10.         NewsTitle new1 = new NewsTitle(1,"天安门1","author");
  11.         NewsTitle new2 = new NewsTitle(7,"天安门7","author");
  12.         NewsTitle new3 = new NewsTitle(3,"天安门3","author");
  13.         NewsTitle new4 = new NewsTitle(5,"天安门5","author");
  15.         list.add(new1);
  16.         list.add(new2);
  17.         list.add(new4);
  18.         list.add(new3);
  19.         // 遍历
  20.         for (NewsTitle newsTitle : list) {
  21.             System.out.println(newsTitle.getTitle());
  22.         }
  23.         System.out.println("===============");
  24.         // 要想对自定义类进行排序，需要重写类的比较规则 compareable
  25.         Collections.sort(list);
  26.         for (NewsTitle newsTitle : list) {
  27.             System.out.println(newsTitle.getTitle());
  28.         }
  30.     }
  31. }
  1. 天安门1
  2. 天安门7
  3. 天安门5
  4. 天安门3
  5. ===============
  6. 天安门1
  7. 天安门3
  8. 天安门5
  9. 天安门7
  11. Process finished with exit code 0