Java基础知识查缺补漏（map、数组、list）

最新推荐文章于 2024-08-05 03:02:28 发布

种子选手席同学

最新推荐文章于 2024-08-05 03:02:28 发布

阅读量686

点赞数

CC 4.0 BY-SA版权

分类专栏： map 数组 Java list 文章标签：基础知识巩固 map 数组

本文链接：https://blog.csdn.net/sinat_41815248/article/details/84899107

Java 同时被 3 个专栏收录

118 篇文章

订阅专栏

数组

11 篇文章

订阅专栏

list

9 篇文章

订阅专栏

本文详细介绍了Java中Map的实例化原理，强调了接口与实现类的区别，讲解了Map的containsKey、get、put等常用方法以及遍历Map的四种方式。此外，还涵盖了数组的初始化、默认值、拷贝以及二维数组的定义。最后讨论了List的初始化，特别是ArrayList和Arrays.asList()方法的使用注意事项。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Map的new为什么是Map map=new HashMap;而不是new Map

Map是接口，HashMap是Map的一种实现。接口不能被实例化。
Map map=new HashMap(); 就是将map实例化成一个HashMap。
这样做的好处是调用者不需要知道map具体的实现，map接口与具体实现的映射java帮你做了。
Map.containsKey方法——判断Map集合对象中是否包含指定的键名。该方法判断Map集合对象中是否包含指定的键名。如果Map集合中包含指定的键名，则返回true，否则返回false。
map.get(“key”);//获取map中键值为“key”的值

Map 一个key对应一个value
put方法中判断key是否为null，当key！=null我们就可以覆盖value值

Map是java中的接口，Map.Entry是Map的一个内部接口。
Map提供了一些常用方法，如keySet()、entrySet()等方法，keySet()方法返回值是Map中key值的集合；entrySet()的返回值也是返回一个Set集合，此集合的类型为Map.Entry。
Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry<K,V>。它表示Map中的一个实体（一个key-value对）。接口中有getKey(),getValue方法。
Map中常用方法

Map map = new HashMap();  //创建map
    Map iMap = new HashMap();
    iMap.put("狂人日记","鲁迅") 
    map.put("家","巴金"); //添加一个键值对，如果key已存在就覆盖，且返回被覆盖的值
    map.put("朝花夕拾","冰心");
    map.put("骆驼祥子","老舍");
    map.put("项链","莫泊桑");
    map.remove("家")  //删除指定key的键值对，返回被删除的key关联的value,不存在返回null
    map.remove("家","巴金")  //删除指定键值对，成功返回true
    map.size() //返回map中键值对的个数
    map.clear()  //删除map中的所有键值对
    map.isEmpty()  //判断map是否为空
    map.get("项链")  //返回指定Key所对应的value,不存在则返回null
    map.containsKey("家") //判断Map中是否包含指定的Key
    map.containsValue("巴金")  //判断Map中是否包含指定的Value
    Collection set = map.entrySet()  //返回Map中键值对所组成的Set.集合元素是Map.Entry(Map的内部类)对象
    Collection set = map.keySet()  //返回Map中key的set集合
    Collection list = map.values()  //返回该Map里所有value组成的Collection

java中遍历map的方式：
方式一这是最常见的并且在大多数情况下也是最可取的遍历方式。在键值都需要时使用。

Map<Integer, Integer> map = new HashMap<Integer, Integer>(); 
for (Map.Entry<Integer, Integer> entry : map.entrySet()) { 
  System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); 
}

方法二在for-each循环中遍历keys或values。

如果只需要map中的键或者值，你可以通过keySet或values来实现遍历，而不是用entrySet。

Map<Integer, Integer> map = new HashMap<Integer, Integer>(); 
//遍历map中的键 
for (Integer key : map.keySet()) { 
  System.out.println("Key = " + key); 
} 
//遍历map中的值 
for (Integer value : map.values()) { 
  System.out.println("Value = " + value); 
}

该方法比entrySet遍历在性能上稍好（快了10%），而且代码更加干净。
方法三使用Iterator遍历
使用泛型：

Map<Integer, Integer> map = new HashMap<Integer, Integer>(); 
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator(); 
while (entries.hasNext()) { 
  Map.Entry<Integer, Integer> entry = entries.next(); 
  System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); 
}

不使用泛型：

Map map = new HashMap(); 
Iterator entries = map.entrySet().iterator(); 
while (entries.hasNext()) { 
  Map.Entry entry = (Map.Entry) entries.next(); 
  Integer key = (Integer)entry.getKey(); 
  Integer value = (Integer)entry.getValue(); 
  System.out.println("Key = " + key + ", Value = " + value); 
}

你也可以在keySet和values上应用同样的方法。

该种方式看起来冗余却有其优点所在。首先，在老版本java中这是惟一遍历map的方式。另一个好处是，你可以在遍历时调用iterator.remove()来删除entries，另两个方法则不能。根据javadoc的说明，如果在for-each遍历中尝试使用此方法，结果是不可预测的。

从性能方面看，该方法类同于for-each遍历（即方法二）的性能。

方法四、通过键找值遍历（效率低）

Map<Integer, Integer> map = new HashMap<Integer, Integer>(); 
for (Integer key : map.keySet()) { 
  Integer value = map.get(key); 
  System.out.println("Key = " + key + ", Value = " + value);

作为方法一的替代，这个代码看上去更加干净；但实际上它相当慢且无效率。因为从键取值是耗时的操作（与方法一相比，在不同的Map实现中该方法慢了20%~200%）。如果你安装了FindBugs，它会做出检查并警告你关于哪些是低效率的遍历。所以尽量避免使用。

总结

如果仅需要键(keys)或值(values)使用方法二。如果你使用的语言版本低于java 5，或是打算在遍历时删除entries，必须使用方法三。否则使用方法一(键值都要)。
Map接口的getOrDefault()方法:

default V getOrDefault(Object key, V defaultValue) {
      V v;
      return (((v = get(key)) != null) || containsKey(key))
          ? v
          : defaultValue;
}

具体的例子，再说明一下：

public class Demo13 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("name", "lxj");
        map.put("age", "24");
        map.put("sex", "女");
        String name = map.getOrDefault("name", "test");
        System.out.println(name);// lxj，map中存在name,获得name对应的value
        String address = map.getOrDefault("address", "北京");
        System.out.println(address);// 北京，map中不存在address,使用默认值“北京”
    }
}

含义：当Map集合中包含这个key时，就使用这个key值；如果没有，就使用默认值defaultValue。
map常用方法
判断map中是否存在这个key：map.containsKey()
判断map中是否存在这个value：map.containsValue()

定义数组

 //声明
　　int[] a;
　　int b[];
 //创建数组对象
　　a = new int[4];
　　b = new int[5];
　　//初始化（对数组元素的初始化）
//默认初始化：数组元素相当于对象的成员变量，默认值跟成员变量的规则一样。数字0，布尔false，char\u0000，引用：null；
//动态初始化：
　　for(int i=0;i<a.length;i++){
　　　　a[i] = i*12;
　　}
//静态初始化
　　int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]
　　nameClass[] c2 = {
　　　　　　　　　　　　new nameClass("联想"),
　　　　　　　　　　　　new nameClass("华硕"),
　　　　　　　　　　　　new nameClass("惠普"),
　　　　　　　　　　　　new nameClass("DELL"),
　　　　　　　　　　　　new nameClass("宏基"),
　　　　　　　　　　　　};
　　nameClass c3 = new nameClass("联想");
　　System.out.println(c3==c2[0]);
}
}

java 在声明了一个数组，并为其分配好存储空间后，未赋值之前会默认对其初始化：

整形数组默认初始值为0；
布尔数组默认初始值为 false；
String 数组以及对象数组初始值为 null.
一维数组的拷贝方式：clone() 方法实现数组拷贝
数组的中间结点就是 A[A.Length/2]

Arrays.fill的用法
用法1：接受2个参数
Arrays.fill（ a1, value ）;
注：a1是一个数组变量，value是一个a1中元素数据类型的值，作用：填充a1数组中的每个元素都是value
例如：

boolean[] a1 = new boolean[5];
Arrays.fill( a1,true );
结果 a1[] = {true,true,true,true,true};
用法2：接受4个参数
例如：
String[] a9 = new String[6];
Arrays.fill(a9, "Hello");
Arrays.fill(a9, 3, 5,"World");
结果是 a9[] = {Hello,Hello,Hello,World,World,Hello};

第一个参数指操作的数组，第二个和第三个指在该数组的某个区域插入第四个参数，第二个参数指起始元素下标（包含该下标），第三个参数指结束下标（不包含该下标），注意：java的数组下标从0开始

二维数组
数组的数组------二维数组的每一个元素是一个一维数组
定义格式
数据类型[][] 数组名 = new 数据类型[二维数组的长度/包含的一维数组的个数][每个一维数组的长度];
int[][] arr = new int[3][5];—定义了一个整型的二维数组，其中包含3个一维数组，每个一维数组可以存储5个整数
arr[0]—下标为0的位置上的一维数组
arr[1][3]—如果要获取具体的元素需要两个下标
数据类型[][] 数组名 = new 数据类型[二维数组的长度/包含的一维数组的个数][];

二维数组的长度：数组名.length —每个一维数组：数组名[下标].length

for(int i = 0; i < arr.length; i++){ //遍历二维数组，遍历出来的每一个元素是一个一维数组
 for(int j = 0; j < arr[i].length; j++){ //遍历对应位置上的一维数组
 System.out.println(arr[i][j]);
 }
}

list的初始化

如果先初始化然后add的方法：

List<String> name = new ArrayList();

name.add("xxx");
name.add("yyy");
name.add("zzz");
list.add(0, temp);//0表示加temp的位置

add方法是在某个指定的位置加上某个对象,并将原来的位置的那个对象向后挤了一格。
list的官方文档，可以看到大大的“Interface List”。所以说List不能直接实例化，而它有许多子类，AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector等。详见这里。

这里需要用的是ArrayList。
所以初始化一个list当然可以用List name = new ArrayList();然后根据需求慢慢add。

更简洁的方法：

List<String> name = Arrays.asList("xxx","yyy","zzz");
(不过这样的话这个list的size就固定了，不能再add了，要注意。)
or    
List<String> name = new ArrayList<>(Arrays.asList("xxx","yyy","zzz"));

Arrays.asList：该方法是将数组转化为list。有以下几点需要注意：

（1）该方法不适用于基本数据类型（byte,short,int,long,float,double,boolean）

（2）该方法将数组与列表链接起来，当更新其中之一时，另一个自动更新

（3）不支持add和remove方法

class Solution {
    public List<List<Integer>> largeGroupPositions(String S) {
        List<List<Integer>> ans = new ArrayList();
        int i = 0, N = S.length(); // i is the start of each group
        for (int j = 0; j < N; ++j) {
            if (j == N-1 || S.charAt(j) != S.charAt(j+1)) {
                // Here, [i, j] represents a group.
                if (j-i+1 >= 3)
                    ans.add(Arrays.asList(new Integer[]{i, j}));
                i = j + 1;
            }
        }
        return ans;
    }
}

List<People> list = new ArrayList<People>();
for(int i = 0;i<list.size();i++){
   People people = list.get(i);
}

当i=0时，取的是list集合中第一个元素，
当i=1时，取的是list集合中第二个元素，
......
当i=i时，取的是list集合中第i+1个元素。

package ListTest;

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

/**
 * @author user:11963
 * @version date：2017年12月19日 下午12:17:56
 * 
 */
public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");// 向集合中追加元素
        list.add(1, "b");// 向集合的制定位置中追加元素
        list.addAll(list);// 向集合追加一个collection，只可追加collection，由于java不提供collection的实现，由它的下级接口来实现
        list.addAll(4, list);// 与上述含义相同， “4”意为追加元素所放的位置
        int i = list.size();// 长度
        System.out.println(i);
        list.get(0);// 根据元素下标来取集合中的元素
        list.remove(7);// 根据集合中元素下标位置来删除元素
        // 此方法是用来比较的，与equals比较相似，现在list的元素中有[a, b, a, b, a, b, a],来和"a,b,c"比较会返回false，
        // 但是注意再用来比较String字符串的时候会进行局部的比较，两组字符串部分相同的情况下会返回true
        list.contains("a,b,c");
        //为了将List转为数组，JDK提供了toArray
        //实现方式一：
        String [] array=(String[]) list.toArray(new String[list.size()]);
        for(String arrays: array) {
            System.out.println(arrays);
        }
        //方式二：
        String [] arr=new String [list.size()];
        list.toArray(arr);
        for(String arrs: arr) {
            System.out.println(arrs);
        }
        //在集合中判断是否为空 ，不空返回false，空会返回true，常常会与null！=list来共同判定集合是否为空，
        //null！=list和list.isempty最大的区别是：一个人要喝水，前者判断是否有水杯，后者判断的是水杯是否有水
        System.out.println(list.isEmpty());//false
        System.out.println(null!=list);//true
        //该方法去比较两个对象时，首先先去判断两个对象是否具有相同的地址，如果是同一个对象的引用，则直接放回true；如果地址不一样，
        //则证明不是引用同一个对象，接下来就是挨个去比较两个字符串对象的内容是否一致，完全相等返回true，否则false。
        //这里会涉及到hashcode相关内容，我会单独开一篇来介绍
        list.equals(arr);//false
        //在集合中查找元素 ，"a"如果有 ,返回所查找元素的下标,如果不存在则返回-1
        list.indexOf("a");
        //打印集合元素
        //方式一：
        Iterator it=list.iterator();
        while(it.hasNext()) {
            String string=(String) it.next();
            System.out.println(string);
        }
        //方式二：
        for (Object o:list) {
            System.out.println(o);
        }
        //方式三：
        for(int s=0;s<list.size();s++) {
            System.out.println(list.get(s));
        }
        //将list释放，元素清空，且无返回值
        list.clear();
        System.out.println(list);

        
    }
}