生如风
github icon

Java—基础知识

author icon生如风calendar icon2022年5月21日category icon
tag icon
timer icon大约 5 分钟

[TOC]

记录下java的一些基础知识。。。

Java学习

基础知识

集合

图片来源：菜鸟教程

集合主要包含单列集合和双列集合

  • Collection接口 -》子接口：List、Set -》实现类是单列，存储value

  • Map接口 -》实现类是双列，存储key-value

List

有序，可重复，允许多个Null元素对象

  • 创建、新增元素
List list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
System.out.println("list = " + list);

list.addAll(Arrays.asList("d","e","f"));
System.out.println("list = " + list);

// list = [a, b, c]
// list = [a, b, c, d, e, f]
  • 删除元素
List list = new ArrayList<>();  
list.add("a");  
list.add("b");  
list.add("c");  
list.add("d");  
System.out.println("list = " + list);  

list.remove("b");  
System.out.println("删除 b 后的 list = " + list);  

list.remove(0);  
System.out.println("删除第 1 个元素后的 1list = " + list);  

list.removeAll(Arrays.asList("c","d"));  
System.out.println("删除 c d 后的元素 list = " + list);



list = [a, b, c, d]
删除 b 后的 list = [a, c, d]
删除第 1 个元素后的 1list = [c, d]
删除 c d 后的元素list = []
  • 遍历

（1）使用iterator迭代器

List list = new ArrayList<>();  
list.add("a");  
list.add("b");  
list.add("c");  
list.add("d");  
System.out.println("list = " + list);  

Iterator it = list.iterator();  
while (it.hasNext()) {  
    System.out.println("元素 = " + it.next());  
}


// list = [a, b, c, d]
元素 = a
元素 = b
元素 = c
元素 = d

（2）增强for

List list = new ArrayList<>();  
list.add("a");  
list.add("b");  
list.add("c");  
list.add("d");  
System.out.println("list = " + list);  

for (Object s : list) {  
    System.out.println("元素 = " + s);  
}

（3）fori

for (int i = 0; i < list.size(); i++) {  
    System.out.println("元素 = " + list.get(i));  
}
  • 去重
List<String> list = new ArrayList<>();  
list.addAll(Arrays.asList("a","b","c","d","c","c","a","d"));  
System.out.println("去重前 list = " + list);  
// 去重  
List<String> list2 = list.stream().distinct().collect(Collectors.toList());  
System.out.println("去重后 list = " + list2);



// 去重前 list = [a, b, c, d, c, c, a, d]
// 去重后 list = [a, b, c, d]

Collectors.toList() 将流中的所有元素导出到一个 List 中

Set

无序，不可重复，最多允许有一个null元素

无序性：不等于随机性，存储的数据在底层并不是按照数据的索引的顺序添加。
会按照其内部算法将元素添加到合适的位置
  • 创建、新增元素
Set set = new HashSet<>();  
set.add("a");  
set.add("b");  
set.add("c");  
System.out.println("set = " + set);  

set.addAll(Arrays.asList("d","e","f"));  
System.out.println("set = " + set);



// set = [a, b, c]
// set = [a, b, c, d, e, f]
  • 删除元素
Set set = new HashSet<>();  
set.add("a");  
set.add("b");  
set.add("c");  
set.addAll(Arrays.asList("d","e","f"));  
System.out.println("set = " + set);  

set.remove("a");  
set.removeAll(Arrays.asList("d","e","f"));  
System.out.println("删除后的 set = " + set);



// set = [a, b, c, d, e, f]
// 删除后的 set = [b, c]

因为set的无序性，所以set的删除元素无法根据index进行删除，也无法使用fori进行遍历。

  • 遍历

（1）使用迭代器

Set set = new HashSet<>();  
set.add("a");  
set.add("b");  
set.add("c");  
Iterator it = set.iterator();  
while (it.hasNext()) {  
    System.out.println("元素 = " + it.next());  
}



元素 = a
元素 = b
元素 = c

（2）增强for

Set set = new HashSet<>();  
set.add("a");  
set.add("b");  
set.add("c");  
for (Object o : set) {  
    System.out.println("元素 = " + o);  
}

Map

Map<String, String> map = new HashMap<String, String>();
map.put("1", "a");
map.put("2", "b");
map.put("1", "c");
System.out.println("map = " + map);

//
map = {1=c, 2=b}

  • key相同，会替换掉前面的key和value的。value无限制。

  • 想要修改value，直接put替换

Map<String, String> map = new HashMap<String, String>();
map.put("1", "a");
map.put("2", "b");
map.put("3", "a");
map.put("4", "a");
// 将key为1的，value修改成aaa
map.put("1", "aaa");
System.out.println("map = " + map);

//
map = {1=aaa, 2=b, 3=a, 4=a}
  • 想要修改key，先remove，再put
Map<String, String> map = new HashMap<String, String>();
        map.put("1", "a");
        map.put("2", "b");
        // 将value为a的key"1"替换为key是111
        if (map.containsKey("1")) {
            String v = map.get("1");
            map.remove("1");
            map.put("111", v);
        }
System.out.println("map = " + map);

//
map = {111=a, 2=b}
  • 遍历

(1)方法一，使用entrySet获取到一个个entry键值映射关系：

Map<String, String> map = new HashMap<String, String>();  
map.put("1", "a");  
map.put("2", "b");  
map.put("3", "c");  
map.put("4", "d");  
for (Map.Entry<String, String> entry : map.entrySet()) {  
    System.out.println("entry = " + entry.getKey() + "---" + entry.getValue());  
}

到这又脑热问自己，fori和增强for有啥不一样。这个也不懂咋的

单纯取数遍历：用增强for

还需要改变元素：用fori

（2）方法二，通过keySet，获取到key，在通过key获取value

Map<String, String> map = new HashMap<String, String>();  
map.put("1", "a");  
map.put("2", "b");  
map.put("3", "c");  
map.put("4", "d");  
for (String k : map.keySet()) {  
    System.out.println("map = " + k + "---" + map.get(k));  
}
// 通过values可以获得map的v
for (String v : map.values()) {
    System.out.println("v = " + v);
}

（3）方法三，使用Iterator

Map<String, String> map = new HashMap<String, String>();  
map.put("1", "a");  
map.put("2", "b");  
map.put("3", "c");  
map.put("4", "d");  
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();  
while (it.hasNext()) {  
    Map.Entry<String, String> entry = it.next();  
    System.out.println("entry = " + entry.getKey() + "---" + entry.getValue());  
}

（4）方法四，使用lambda

Map<String, String> map = new HashMap<String, String>();  
map.put("1", "a");  
map.put("2", "b");  
map.put("3", "c");  
map.put("4", "d");  
map.forEach((k, v) -> {  
    System.out.println(k + "---" + v);  
});

lambda无法修改局部变量，也就是如果在这个map.forEach中，执行put或remove无法成功

单纯遍历：lambda效率更高些

还是推荐用entrySet，直接都取到key和value

流

字符流

编码：采用unicode编码（有UTF-8、UTF-16等）。

缓冲区：使用

字符在JVM内部都是unicode，当这个字符被从JVM内部转移到外部时（例如存入文件系统），需要进行编码转换，InputStreamReader 和 OutputStreamReader，

这两个类是字节流和字符流之间的适配器类。

字节流

编码：采用ascll编码

缓冲区：默认不使用

抽象类和接口

同：

  • 都不能被实例化，可以定义抽象类和接口类的引用。

  • 一个类如果基础了某个抽象类或实现了某个接口类，都要对里面的抽象方法进行全部实现，否则这个类还是定义为抽象类。

异：

  • 抽象类可以有构造器、抽象方法、具体方法；接口没有构造器，方法都是抽象方法。

  • 抽象类成员修饰类型可以全都有，可以定义成员变量；接口都是public，定义的成员变量实际都是常量。

  • 抽象类不一定有抽象方法，但是有抽象方法的类必须是抽象类。

可以看看我的学习——基于Hexo的个人博客： 网站：http://www.fuzm.wangopen in new window ————————————————————————— 作为初学者，很多知识都没有掌握，见谅，如有错误请指出，以期进步，感谢！。后续有新的学习，继续补充上来。

默认页脚
Copyright © 2026 生如风