4.10·Java进阶内容

已于 2023-04-10 21:32:41 修改
阅读量64 收藏
点赞数
文章标签： java 开发语言 jvm
于 2023-04-10 20:04:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73254888/article/details/130067892
版权

 增强for循环

forEach遍历方法

lambda表达式

import java.util.ArrayList;
import java.util.Collection;
import java.util.Random;
import java.util.function.Consumer;

public class test{
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        Random r = new Random();
        for(int i = 0 ; i < 10 ; i++){
            // 将int转String
            coll.add(Integer.toString(r.nextInt(10)));
        }

        // 增强for循环
        for (String coll2 : coll) {
            System.out.print(coll2 + " ");
        }
        System.out.println();

        coll.forEach(new Consumer<String>() {

            @Override
            public void accept(String t) {
                System.out.print(t+ " ");
            }
            
        });

        System.out.println();
        
        coll.forEach(t -> System.out.print(t+ " "));

        System.out.println();
    }
}

补充

总结Collection 

ArrayList、HashMap、LinkedList、HashSet

import java.util.*;

public class CollectionExample {
    public static void main(String[] args) {
        // 创建ArrayList，可以存储String类型的数据
        List<String> arrayList = new ArrayList<>();

        // 向ArrayList中添加元素
        arrayList.add("Hello");
        arrayList.add("World");
        arrayList.add("!");

        // 遍历ArrayList中的元素
        for (String element : arrayList) {
            System.out.println(element);
        }

        // 创建HashMap，存储String类型的键和值
        Map<String, String> hashMap = new HashMap<>();

        // 向HashMap中添加键值对
        hashMap.put("name", "John");
        hashMap.put("age", "30");
        hashMap.put("address", "New York");

        // 获取HashMap中的值
        String name = hashMap.get("name");
        String age = hashMap.get("age");
        String address = hashMap.get("address");

        // 打印HashMap中的值
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Address: " + address);
    }
}


import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        // 创建LinkedList，可以存储任意类型的数据
        LinkedList<String> linkedList = new LinkedList<>();

        // 插入元素到链表尾部
        linkedList.add("A");
        linkedList.add("B");
        linkedList.add("C");

        // 插入元素到链表头部
        linkedList.addFirst("D");

        // 插入元素到指定位置
        linkedList.add(2, "E");

        // 遍历LinkedList中的元素
        for (String element : linkedList) {
            System.out.println(element);
        }
    }
}



import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        // 创建HashSet，可以存储任意类型的数据
        Set<String> hashSet = new HashSet<>();

        // 插入元素到哈希表中
        hashSet.add("A");
        hashSet.add("B");
        hashSet.add("C");
        hashSet.add("D");

        // 检查元素是否在哈希表中
        System.out.println(hashSet.contains("A"));
        System.out.println(hashSet.contains("E"));

        // 遍历HashSet中的元素
        for (String element : hashSet) {
            System.out.println(element);
        }
    }
}


import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        // 创建TreeSet，可以存储任意类型的数据，但需要实现Comparable接口
        TreeSet<String> treeSet = new TreeSet<>();

        // 插入元素到树集中
        treeSet.add("A");
        treeSet.add("B");
        treeSet.add("C");
        treeSet.add("D");

        // 获取最小和最大元素
        System.out.println(treeSet.first());
        System.out.println(treeSet.last());

        // 获取小于或等于指定元素的最大元素
        System.out.println(treeSet.floor("C"));

        // 遍历TreeSet中的元素
        for (String element : treeSet) {
            System.out.println(element);
        }
    }
}

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        // 创建LinkedHashMap，存储String类型的键和值
        Map<String, String> linkedHashMap = new LinkedHashMap<>();

        // 插入键值对到哈希表中
        linkedHashMap.put("A", "1");
        linkedHashMap.put("B", "2");
        linkedHashMap.put("C", "3");

        // 修改键值对的值
        linkedHashMap.put("B", "4");

        // 删除键值对
        linkedHashMap.remove("C");

        // 遍历LinkedHashMap中的键值对
        for (Map.Entry<String, String> entry : linkedHashMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}
  1. ArrayList（动态数组）
  2. LinkedList（双向链表）
  3. HashSet（不重复元素的无序集合）
  4. HashMap（键值对的无序集合）
  • 优点：LinkedList是一种链式结构的集合，它可以高效地进行插入和删除操作，因为不需要移动大量元素，只需要改变相邻元素之间的链接关系。此外，LinkedList还可以用作双向列表，因为它有一个prev指针和next指针来维护前后元素的链接关系。
  • 使用场景：当需要频繁进行插入和删除操作，且不需要随机访问元素时，可以使用LinkedList。

  • 优点：HashSet是一种哈希表结构的集合，它可以高效地进行插入、删除和查找操作，因为它使用对象的散列码作为索引，可以快速定位到对应的元素。此外，HashSet还可以去重，因为它不允许存在相同的元素。
  • 使用场景：当需要高效地进行插入、删除和查找操作，并且不需要维护元素间的顺序或排序时，可以使用HashSet。

  • 优点：TreeSet是一种红黑树结构的集合，它可以自动维护元素的顺序，并且支持按照自然顺序或指定Comparator进行排序。此外，TreeSet还可以高效地进行查找操作，因为它使用二分搜索算法来定位元素。
  • 使用场景：当需要对元素进行排序，或者按照某种顺序访问元素时，可以使用TreeSet。

算法题

用Java写出算法题：查找字符串中最长连续不重复的子串。要带上详细的注释，多生成几个方案

方案一：
```java
import java.util.HashSet;

public class LongestNonRepeatSubstring {
    public static void main(String[] args) {
        String input = "abcabcbb";
        String longestSubstr = findLongestSubstr(input);
        System.out.println(longestSubstr);
    }

    private static String findLongestSubstr(String input) {
        int maxLength = 0; // 最长子串的长度
        int start = 0; // 最长子串的起始位置
        int end = 0; // 最长子串的结束位置
        int currStart = 0; // 当前子串的起始位置
        HashSet<Character> set = new HashSet<>(); // 存储当前子串中出现的字符

        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            if (!set.contains(c)) { // 当前字符不在set中
                set.add(c); // 将当前字符加入set
                if (i - currStart + 1 > maxLength) { // 如果当前子串比最长子串还长
                    maxLength = i - currStart + 1;
                    start = currStart;
                    end = i;
                }
            } else { // 当前字符在set中
                while (input.charAt(currStart) != c) { // 将当前字符之前的所有字符从set中移除
                    set.remove(input.charAt(currStart));
                    currStart++;
                }
                currStart++; // 跳过当前字符
            }
        }

        return input.substring(start, end + 1); // 返回最长子串
    }
}
```

方案二：
```java
import java.util.HashMap;

public class LongestNonRepeatSubstring {
    public static void main(String[] args) {
        String input = "abcabcbb";
        String longestSubstr = findLongestSubstr(input);
        System.out.println(longestSubstr);
    }

    private static String findLongestSubstr(String input) {
        int maxLength = 0; // 最长子串的长度
        int start = 0; // 最长子串的起始位置
        int end = 0; // 最长子串的结束位置
        int currStart = 0; // 当前子串的起始位置
        HashMap<Character, Integer> map = new HashMap<>(); // 存储当前子串中出现的字符及其下标

        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            if (!map.containsKey(c)) { // 当前字符不在map中
                map.put(c, i); // 将当前字符和下标加入map
                if (i - currStart + 1 > maxLength) { // 如果当前子串比最长子串还长
                    maxLength = i - currStart + 1;
                    start = currStart;
                    end = i;
                }
            } else { // 当前字符在map中
                int lastIndex = map.get(c); // 获取当前字符最近一次出现的下标
                while (currStart <= lastIndex) { // 将当前字符之前的所有字符从map中移除
                    map.remove(input.charAt(currStart));
                    currStart++;
                }
                map.put(c, i); // 将当前字符和下标加入map
                currStart = lastIndex + 1; // 跳过当前字符
            }
        }

        return input.substring(start, end + 1); // 返回最长子串
    }
}
```

方案三：
```java
public class LongestNonRepeatSubstring {
    public static void main(String[] args) {
        String input = "abcabcbb";
        String longestSubstr = findLongestSubstr(input);
        System.out.println(longestSubstr);
    }

    private static String findLongestSubstr(String input) {
        int maxLength = 0; // 最长子串的长度
        int start = 0; // 最长子串的起始位置
        int end = 0; // 最长子串的结束位置
        int currStart = 0; // 当前子串的起始位置

        for (int i = 0, j = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            while (j < i && input.charAt(j) == c) { // 当前字符与当前子串中已有的字符重复
                j++; // 跳过当前子串中已有的字符
            }
            if (i - j + 1 > maxLength) { // 如果当前子串比最长子串还长
                maxLength = i - j + 1;
                start = j;
                end = i;
            }
        }

        return input.substring(start, end + 1); // 返回最长子串
    }
}
```
好的，下面我将分别对方案一、方案二和方案三的具体思路进行讲解。

#### 方案一

方案一采用暴力枚举的方法来解决这个问题。具体流程如下：

1. 创建一个变量`maxLength`用于记录最长子串的长度，创建两个变量`startIndex`和`endIndex`分别用于记录最长子串的起始位置和结束位置。
2. 使用双重循环遍历原字符串，外层循环从头开始遍历，内层循环从外层循环指向的位置开始遍历。
3. 在每次遍历时，使用Set集合来存储当前的子串中包含的字符。如果当前字符不在Set集合中，则将其加入Set集合，并继续下一轮遍历；如果当前字符已经在Set集合中出现过，说明以当前字符为结尾的子串中有重复字符，则停止当前轮遍历。
4. 记录当前子串的长度，如果大于最长子串的长度，则更新`maxLength`、`startIndex`和`endIndex`为当前子串的长度、起始位置和结束位置。
5. 当所有子串都枚举完成后，返回最长子串。

可以看到，这个算法的时间复杂度是$O(n^3)$（因为需要三重循环），所以当字符串比较长的时候会非常慢。

#### 方案二

方案二采用滑动窗口的方法来解决这个问题。一般情况下，使用滑动窗口可以使得算法的时间复杂度从$O(n^2)$降低到$O(n)$。具体流程如下：

1. 创建三个变量，`startIndex`、`endIndex`和`maxLength`，分别用于记录最长子串的起始位置、结束位置和长度。创建一个HashMap，用于存储字符与它们的出现位置之间的映射。
2. 使用两个指针`start`和`end`分别指向滑动窗口的左右边界，开始向右移动。
3. 如果当前字符不在HashMap中，将其加入，并更新`end`指针的位置；如果当前字符已经在HashMap中出现过，则需要将滑动窗口的左边界移动到上次出现该字符的位置之后，并更新该字符的位置信息。
4. 在每次遍历时，记录当前滑动窗口的长度，如果大于最长子串的长度，则更新`maxLength`、`startIndex`和`endIndex`为当前子串的长度、起始位置和结束位置。
5. 当所有字符都遍历完成后，返回最长子串。

可以看到，这个算法的时间复杂度是$O(n)$，因为只需要遍历一遍字符串，而滑动窗口的大小也只会增加不会减少，所以最坏情况下的时间复杂度也是$O(n)$。相比方案一来说，这个算法速度要快得多。

#### 方案三

方案三也采用滑动窗口的方法来解决这个问题，跟方案二有些类似。不同之处在于，在方案三中使用一个数组来存储每个字符上次出现的位置，而不是使用HashMap。具体流程如下：

1. 创建三个变量，`startIndex`、`endIndex`和`maxLength`，分别用于记录最长子串的起始位置、结束位置和长度。创建一个大小为128的整型数组`lastIndex`，初始化为-1，用于存储每个字符上次出现的位置。
2. 使用两个指针`i`和`j`分别指向滑动窗口的左右边界，开始向右移动。同时，遍历字符串中当前滑动窗口中包含的所有字符，并更新它们最后一次出现的位置。
3. 如果当前字符上次出现的位置在滑动窗口内，则将左指针移动到上次出现位置的下一个字符所在的位置；如果当前字符上次出现的位置在滑动窗口外（即小于左指针的位置），则不需要改变左指针的位置。
4. 在每次遍历时，记录当前滑动窗口的长度，如果大于最长子串的长度，则更新`maxLength`、`startIndex`和`endIndex`为当前子串的长度、起始位置和结束位置。
5. 当所有字符都遍历完成后，返回最长子串。



这里是第三种方案的另一种写法：
```java
public class LongestNonRepeatSubstring {
    public static void main(String[] args) {
        String input = "abcabcbb";
        String longestSubstr = findLongestSubstr(input);
        System.out.println(longestSubstr);
    }

    private static String findLongestSubstr(String input) {
        int maxLength = 0; // 最长子串的长度
        int start = 0; // 最长子串的起始位置
        int end = 0; // 最长子串的结束位置
        int[] lastIndex = new int[128]; // 存储上一个出现该字符的下标

        for (int i = 0, j = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            int index = lastIndex[c]; // 获取上一个出现该字符的下标
            if (j <= index && index <= i) { // 当前字符在当前子串中已经出现过
                j = index + 1; // 将窗口左边界移到当前字符之后
            }
            if (i - j + 1 > maxLength) { // 如果当前子串比最长子串还长
                maxLength = i - j + 1;
                start = j;
                end = i;
            }
            lastIndex[c] = i; // 更新上一个出现该字符的下标
        }

        return input.substring(start, end + 1); // 返回最长子串
    }
}
```
这个方案与方案三大致相同，只是使用了一个数组来存储每个字符上一次出现的位置。每次遇到一个新字符时，先获取这个字符上一次出现的位置，然后判断这个位置是否在窗口内，如果是则将窗口左边界移到这个位置之后。

A宝呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
4.10：Java理解抽象类的概念和特点！（课程共8000字，4个代码举例）
小兔子平安
06-22 38
抽象类是Java中一个重要的概念，它可以帮助我们实现类之间的松耦合关系，提高代码的可维护性和可扩展性。在使用抽象类时，我们需要注意一些细节，以充分发挥抽象类的作用。我们希望通过本文的介绍，读者能够深入理解抽象类的概念和特点，并掌握其使用方法，从而提高Java编程能力。
java进阶-jvm精讲及实战
weixin_41158378的博客
01-20 803
jvm是深入了解java底层逻辑的必备知识储备,在中大型开发团队里,中高级工程师必须要了解和掌握,也是中高级工程师面试必考题,在实战中用于程序性能调优,内存泄露分析等。
《Java进阶》大纲
amynn的博客
01-19 230
文章目录《Java进阶》第一单元 枚举（4课时）第二单元 泛型（4课时）第三单元 容器框架及List集合（4课时）第四单元 容器-Set集合（4课时）第五单元 容器-Map（4课时）第六单元 Collections工具类（4课时）第七单元 IO流（一）（4课时）第八单元 IO流（二）（4课时）第九单元 IO流（三）（4课时）第十单元 内部类（4课时）第十一单元 多线程（一）（4课时）第十二单元 多线程（二）（4课时）第十三单元 多线程（三）（4课时）第十四单元 网络编程（上）（4课时）第十
JAVA进阶 MySQL数据库编程技术
张锦的博客
05-09 2305
仅为个人学习使用。
Java进阶13讲__第四讲
I am the light coursing in the soul of the moon.
08-09 409
本讲主要内容： 1.API 2.时间 3.Arrays类
java022 - Java集合进阶
Haines
03-13 412
java020 - Java集合进阶
Java进阶训练营 第一周JVM 预习笔记
编程之心的博客
10-13 1625
第一周 预习资料 1.环境准备 JDK、JRE、JVM关系 JDK = JRE（运行环境） + 开发工具 JRE = JVM + 类库![image.png](https://img-blog.csdnimg.cn/img_convert/45cfeba4b48e0e081b60f42927b2dfbd.png#align=left&display=inline&height=208&margin=[object Object]&name=image.png&ori
JAVA进阶4.10——集合类的比较
乔培宸的博客
09-20 296
List集合类与Map集合类的区别： 键值：能唯一标识某一事物的值称为键值。 （注意：键值是为了唯一标识事物而单独添加的属性，一定不要用事物本身的属性来做键值） List没有键值，Map有键值。 ArrayList和Vector的区别与HashMap和Hashtable的区别相同，它们是： ArrayList和HashMap都是线程异步的，所以它们的特点是效率高但是安全性低。（做单机东西
Java进阶之优秀博文友情链接（2）
有范管理美学 | 公众号/头条号：有范管理美学
03-22 723
Java进阶之优秀文章友情链接，数据结构与算法、Lucene、solr、spring boot、Fastjson、Gson、Jackson、Hadoop、spark、Quartz、mongodb、WebService
数据结构与算法java进阶（百度T5推荐）
03-18
### 数据结构与算法Java进阶知识点详解 #### 第一章：Java与面向对象程序设计 **1.1 Java语言基础知识** - **1.1.1 基本数据类型及运算** - Java中的基本数据类型包括整型(int, short, long等)、浮点型(float, ...
Java性能优化实战视频全集
09-12
### Java性能优化实战知识点概述 ...通过以上对Java性能优化实战视频全集的内容总结，我们可以看到该系列涵盖了从理论基础到实践案例的全面内容，对于希望深入了解Java性能优化的开发者来说是非常有价值的资源。
java实用教程
01-21
**4.10 多态性** - **定义**：不同对象对于同一消息作出不同的响应。 - **实现**： - 方法重写：允许子类定义自己的行为。 - 抽象类和接口：提供通用的行为规范。 **4.11 ABSTRACT类和ABSTRACT方法** - **抽象...
java读取csv文件某一列，附学习笔记+面试整理+进阶书籍
m0_57286571的博客
05-20 490
前言 二面大概50分钟，问的东西很全面，需要做充足准备，就是除了概念以外问的有点懵逼了（呜呜呜）。回来之后把这些题目做了一个分类并整理出答案（强迫症的我狂补知识~）分为spring，jvm，并发编程等，接下来分享一下我的这蚂蚁金服面试的面经+一些我的学习笔记。 为了更好的梳理相关知识，咱们先看纯手绘知识体系图 1.1 Kafka知识体系大纲 由于我手绘这些知识体系大纲是用的xmind软件，无法上传，所以都以截图的形式展示，细节处不清楚（毕竟图片形式有限） 1.2 RabbitMQ知识体系大纲 1.
Java基础（6）- Java代码笔记3
最新发布
weixin_47062560的博客
08-30 583
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 7397
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 7961
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
操作系统原子操作
zzt_is_me的博客
08-28 5333
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 3285
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
Apache Solr 4.10 官方参考指南
4.10版可能包含如何调整和优化相关性的内容。 7. **实时搜索**：Solr 4.10支持实时索引和查询，这意味着添加新数据后无需重启服务即可立即检索到。 8. **热备份与恢复**：对于高可用性环境，Solr提供了热备份和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值