集合

1、介绍

Java 数组几个特点

  • 连续的
  • 大小固定
  • 数据类型完全一致 (如果是小的数据类型，可自动转换为大的数据类型)
  • 数组是储存在堆上的对象，可以保存多个同类型变量

2、案例

2.1、定义数组

  2. public class Test2 {
  4.     public static void main(String[] args) {
  6.         //静态初始化
  7.         int[] arr = new int[10];
  8.         arr[0] = 100;
  9.         arr[1] = 200;
  10.         arr[2] = '啊'; //小的类型，自动转换为大的
  12.         int arr_length = arr.length;    //数组长度，10
  13.         int arr_key3 = arr[2];
  14.         System.out.println(arr_key3);
  17.         //静态初始化
  18.         int[] arr_two = {1,2,3,4,5,6,7};
  19.         System.out.println(arr_two.length);
  21.     }
  23. }

2.2、 MAP

  1. import java.util.Map;
  2. import java.util.HashMap;
  4. public class Test2 {
  6.     public static void main(String[] args) {
  8.         //1、定义 MAP
  9.         Map<String, String> map_1 = new HashMap<String, String>();
  10.         map_1.put("a", "第四条新闻");
  11.         map_1.put("b", "第五条新闻");
  12.         map_1.get("a");
  13.         //循环
  14.         for(Map.Entry<String, String> entry :map_1.entrySet()) {
  15.             System.out.println(entry.getKey());
  16.             System.out.println(entry.getValue());
  17.         }
  19.         // 初始化
  20.         Map<String, String> map = new HashMap<String, String>() {
  21.             {
  22.                 put("Name", "June");  
  23.                 put("QQ", "4889983");  
  24.             }
  25.         };
  28.         //2、定义指定类型的，泛型 MAP
  29.         Map<Integer,String> map_2 = new HashMap<Integer,String>();
  30.         map_2.put(1,"a");
  31.         map_2.put(2,"b");
  34.         //3、定义指定的自定义对象 Map
  35.         Map<Integer,NewsEntity> map_2 = new HashMap<Integer,NewsEntity>();
  36.         map_2.put(1,new NewsEntity(1,"标题1"));
  37.         map_2.put(2,new NewsEntity(2,"标题2"));
  38.         map_2.get(1).getNewsname();
  39.         //循环
  40.         for(Map.Entry<Integer,NewsEntity> entry : map_2.entrySet()) {
  41.           System.out.println(entry.getKey());
  42.           System.out.println(entry.getValue().getNewsname());//打印出对象中的值
  43.         }
  46.         // 自定义 Object 的 Map
  47.         Map<String,Object> map_3 = new HashMap<String, Object>();
  48.         for(Map.Entry<String, Object> entry : map_3.entrySet()) {
  49.             resultMap.put(entry.getKey(), entry.getValue());
  50.         }
  53.         //4、LinkedHashMap
  54.         Map<Integer,String> map_list = new LinkedHashMap<Integer,String>();
  55.         map_list.put(1, "星期一");
  56.         map_list.put(2, "星期二");
  57.         map_list.put(3, "星期三");
  58.         map_list.put(4, "星期四");
  59.         map_list.put(5, "星期五");
  60.         map_list.put(6, "星期六");
  61.         map_list.put(7, "星期日");
  62.         //循环 LinkedHashMap
  63.         for(Map.Entry<Integer, String> entry: map_list.entrySet()) {
  64.             System.out.print(entry.getKey() + ":" + entry.getValue() + "\t");
  65.         }
  68.         // 5. 循环嵌套
  69.         Map<String, Map<String,String>> mapDemo = new HashMap<String, Map<String,String>>();
  71.         // 方法 1
  72.         Iterator<Map.Entry<String, Map<String, String>>> mapDemoEntries = mapDemo.entrySet().iterator();
  73.         while (actionNeedsEntries.hasNext()) {  
  74.             Map.Entry<String, Map<String, String>> entry = mapDemo.next();  
  75.             System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  
  76.         }
  78.         // 方法 2
  79.         for(Map.Entry<String, Map<String, String>> curMap : mapDemo.entrySet()) {
  80.            String key = curMap.getKey();
  81.            Map<String, String> curMapInfo = curMap.getValue();
  83.            System.out.println("Key = " + key + ", Value = " + curMapInfo);  
  84.        }
  88.     }
  90. }

2.3 、 List

  1. import java.util.Map;
  2. import java.util.HashMap;
  3. import java.util.List;
  4. import java.util.ArrayList;
  5. import java.util.Arrays;
  8. public class Test3 {
  10.     public static void main(String[] args) {
  12.         //定义 List
  13.         List list_1 = new ArrayList();
  14.         list_1.add(1);
  15.         list_1.add("a");
  16.         list_1.get(0);
  18.         //定义明确类型的泛型 List
  19.         List<String> list_2 = new ArrayList<String>();
  20.         list_2.add("a");
  21.         list_2.add("b");
  22.         list_2.get(0);
  24.         //定义自定义对象的 List
  25.         List<NewsEntity> list_3 = new ArrayList<NewsEntity>();
  26.         list_3.add(new NewsEntity(1,"标题1"));
  27.         list_3.add(new NewsEntity(2,"标题2"));
  28.         list_3.get(0).getNewsname();//获取对应下标的对象方法
  31.         // list 放入 map
  32.         List<Map<String, String>> listResult = new ArrayList<Map<String, String>>();
  33.         Map<String, String> mapRowData = new HashMap<String, String>();
  35.         // 初始化 list 的值
  36.         List<String> listFields = Arrays.asList("id","name");
  38.         // 遍历 List
  39.         for (int i =0; i <= listResult.size()-1; i ++) {
  40.           String col = rs.get(i);
  41.           System.out.println(col);
  42.         }
  44.         // 第二种方式
  45.         for( Map<String, String> curMap :listResult){
  47.             // 当前推荐出来的房源 ID
  48.             String value = curMap.get("key");
  49.         }
  53.         // Ids
  54.         List ids = new ArrayList<String>();
  55.         ids.add("1");
  56.         ids.add("2");
  57.         ids.add("3");
  59.         // 组合成字符串 commons-lang.jar   org.apache.commons.lang.StringUtils
  60.         StringUtils.join(ids,",");
  62.         // 字符串转 list
  63.         String ids = "2;3";
  64.         String[] idsArr =new String[]{};
  65.         idsArr = str.split(",");
  66.         List list = java.util.Arrays.asList(idsArr);
  68.         // 简写
  69.         List<String> strTolist =  Arrays.asList("2;3".split(";"));
  71.         // list 转 array
  72.         String[] listToArr = (String[]) list.toArray(new String[list.size]);
  74.     }
  76. }

2.3 自定义对象数组

  3. public class Test4 {
  5.   public static void main (String[] args) {
  7.         MyClass[] myClass = new MyClass[10];
  9.         myClass[0] = new MyClass();
  10.         myClass[0].setName("abc");
  12.         System.out.println(myClass[0].getName());
  13.     }
  14. }

2.4 排序

  2. import java.util.Collections;
  3. import java.util.Comparator;
  4. import java.util.Map.Entry;
  6. // 一、对 Map<String, Map<String,String>> 进行排序
  8.     Map<String, Map<String,String>> map = new HashMap<String, Map<String,String>>();
  10.     // 转换成 list
  11.     List<Map.Entry<String, Map<String, String>>> sortMapList = new ArrayList<Map.Entry<String, Map<String, String>>>(map.entrySet());
  13.     // 排序
  14.     Collections.sort(sortMapList,new Comparator<Map.Entry<String, Map<String, String>>> (){
  15.         @Override
  16.         public int compare(Entry<String, Map<String, String>> o1, Entry<String, Map<String, String>> o2) {
  17.           // 升序
  18.           return Integer.parseInt(o2.getValue().get("key")) - Integer.parseInt(o1.getValue().get("key"));
  20.           // 降序
  21.           return Integer.parseInt(o2.getValue().get("key")) - Integer.parseInt(o1.getValue().get("key"));
  22.         }
  23.     });
  26. // 二、对 List<Map<String,String>> 排序
  28.     List<Map<String, String>> listMap = new ArrayList<Map<String, String>>();
  30.     // 排序
  31.     Collections.sort(listMap,new Comparator<Map<String, String>> (){
  32.         @Override
  33.         public int compare(Map<String, String> o1, Map<String, String> o2) {
  35.           // 升序
  36.           return Integer.parseInt(o1.get("xxx")) - Integer.parseInt(o2.get("xxx"));
  37.           // 降序
  38.           return Integer.parseInt(o2.get("xxx")) - Integer.parseInt(o1.get("xxx"));
  39.         }
  40.     });