Java笔记(3)

简介: 该文介绍了数据结构的基础知识,包括集合类型和遍历方式。集合分为ArrayList(有序、可重复、有索引)和Set(无序、不重复、无索引)。遍历集合可使用Iterator、增强for循环和Lambda表达式。HashMap是Map接口的实现,用于存储键值对,提供添加、删除、查找等操作。LinkedHashMap保持插入顺序。文章还提及了二叉树的概念,如平衡二叉树和红黑树,并列举了一些常用的Java开发快捷键,以及如何添加依赖。

数据结构

集合(Collection)

image-20240514190113288.png

list系列集合:

添加的元素是有序(录入)、可重复、有索引

ArrayList<String> list = new ArrayList<>();

set系列集合:

添加的元素是无序,不重复,无索引的

.add()
.contains(“STRING”)
.size()

列表迭代器遍历

ListIterator<String> iterator = list.listIterator();
        while (iterator.hasNext()){
   
   
            String s = iterator.next();
            if(s.equals("b")){
   
   
                iterator.remove();//iterator.add("qqq");
            }
            System.out.println(s);
        }

集合遍历

  1. Iteratoriterator

     Iterator<String> iterator = collection.iterator();
             while (iterator.hasNext()){
         
         
                 String s = iterator.next();
                 System.out.println(s);
             }
    
  1. 增强for

     for (String s : collection) {
         
         
                 System.out.println(s);
             }
     //s是临时变量,如果修改了增强for中的变量是不会改变集合中原本的数据
    
  1. Lambda遍历

      collection.forEach(s->System.out.println(s));
    
Set<String>set1=new HashSet<>();
Set<String> set = list.stream().collect(Collectors.toSet());

==三种通用的遍历方式:
迭代器:在遍历的过程中需要删除元素,请使用迭代器。
增强for、Lambda: 仅仅想遍历,那么使用增强for或Lambda表达式==

image-20240514200830393.png

HashMap

image-20240523123556294.png

==Map是双列集合的顶层接口,他的功能是全部双列集合继承使用的==

        //创建Map集合对象
        Map<String,String> m = new HashMap<>();
        //添加元素
        //put 添加和覆盖
        //如果键不存在则添加,返回null
        // 如果键存在则覆盖,并把原有的数据返回
        m.put("Leo","Ann");
        m.put("Luck","Lucy");
        String s = m.put("Anna","Lucy");
        System.out.println(s);//原数据中没有anna,所以返回null

        String s1 = m.put("Luck","Fuck");
        System.out.println(s1);

        String result = m.remove("Leo");
        System.out.println(result);
        //删除返回被删除的值
        String s2 = m.remove("Luck");
        System.out.println(s2);
        //判断键是否存在
        boolean valueResult = m.containsValue("Lucy");
        System.out.println(valueResult);
        boolean isResult = m.isEmpty();
        if(isResult){
   
   
            System.out.println("集合为空");
        }else{
   
   
            System.out.println("集合不为空");
        }
        System.out.println(m);

        Map<String,String>map = new HashMap<>();
        map.put("Leo","Ann");
        map.put("Luck","Lucy");
        map.put("Anna","Lucy");

        Set<String> keys = map.keySet();

        //增强for循环遍历
        for (String key : keys) {
   
   
            System.out.println(key);
            String value = map.get(key);
            System.out.println(key+"="+value);
        }

        //lambda表达式遍历
        map.keySet().forEach(key->{
   
   
            System.out.println(key);
            String value = map.get(key);
            System.out.println(key+"="+value);
        });

        //迭代器遍历
        Iterator<String> it = map.keySet().iterator();
        while(it.hasNext()){
   
   
            String key = it.next();
            System.out.println(key);
            String value = map.get(key);
            System.out.println(key+"="+value);
        }

        //增强for循环遍历
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        for (Map.Entry<String,String> entry : entrySet) {
   
   
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }

        for(Map.Entry<String,String> entry : map.entrySet()){
   
   
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }

        //lambda表达式遍历
        map.forEach(new BiConsumer<String, String>() {
   
   
            @Override
            public void accept(String key, String value) {
   
   
                System.out.println(key + "=" + value);
            }
        });
        System.out.println("---------------------");
        map.forEach((String key,String value)->{
   
   
            System.out.println(key+"="+value);
        });

LinkedHashMap

image-20240523124332017.png

二叉树(BinaryTree)

平衡二叉树

红黑树

image-20240515154357633.png

常用快捷键

Alt + enter 一键补全

Alt + insert 一键初始化改写

Ctrl + n 查找类名源代码

Ctrl + b 查看源代码

Ctrl + Alt + m 代码提取,封装成方法

Ctrl + Alt + ← 回到上一个源码类

Ctrl + F12 查找用法

Ctrl + Alt + l 规范代码

Alt + 7 查看代码结构

Ctrl AIT v Runtime.getRuntime();===>Runtime runtime = Runtime.getRuntime();

添加依赖(导包)

在根目录新建lib文件夹,导入代码,并右键点击add as library

目录
相关文章
|
2月前
|
Java 开发工具 Android开发
Kotlin语法笔记(26) -Kotlin 与 Java 共存(1)
本系列教程笔记详细讲解了Kotlin语法,适合需要深入了解Kotlin的开发者。若需快速学习Kotlin,建议查看“简洁”系列教程。本期重点介绍了Kotlin与Java的共存方式,包括属性、单例对象、默认参数方法、包方法、扩展方法以及内部类和成员的互操作性。通过这些内容,帮助你在项目中更好地结合使用这两种语言。
49 1
|
2月前
|
Java 开发工具 Android开发
Kotlin语法笔记(26) -Kotlin 与 Java 共存(1)
Kotlin语法笔记(26) -Kotlin 与 Java 共存(1)
34 2
|
15天前
|
安全 Java 编译器
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)
|
15天前
|
Java 开发工具 Android开发
Kotlin教程笔记(26) -Kotlin 与 Java 共存(一)
Kotlin教程笔记(26) -Kotlin 与 Java 共存(一)
|
22天前
|
Java 编译器 Android开发
Kotlin教程笔记(28) -Kotlin 与 Java 混编
Kotlin教程笔记(28) -Kotlin 与 Java 混编
27 2
|
14天前
|
Java 数据库连接 编译器
Kotlin教程笔记(29) -Kotlin 兼容 Java 遇到的最大的“坑”
Kotlin教程笔记(29) -Kotlin 兼容 Java 遇到的最大的“坑”
34 0
|
1月前
|
安全 Java 编译器
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)
|
1月前
|
Java 开发工具 Android开发
Kotlin教程笔记(26) -Kotlin 与 Java 共存(一)
Kotlin教程笔记(26) -Kotlin 与 Java 共存(一)
|
1月前
|
Java 编译器 Android开发
Kotlin教程笔记(28) -Kotlin 与 Java 混编
Kotlin教程笔记(28) -Kotlin 与 Java 混编
|
27天前
|
Java 编译器 Android开发
Kotlin教程笔记(28) -Kotlin 与 Java 混编
Kotlin教程笔记(28) -Kotlin 与 Java 混编
12 0