Java 基础知识点 笔记总结 (九)

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量723 收藏 19
点赞数 13
分类专栏： 程序员 文章标签： java 笔记 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Z70czd/article/details/137758967
版权

import java.util.Arrays;

import java.util.Collection;

public class CollectionTest {

@Test

public void test1(){

Collection coll = new ArrayList();

//这里的123是一个对象

coll.add(123);

coll.add(456);

coll.add(new String(“Tom”));

coll.add(false);

coll.add(new Person(“hello”,22));

Person p = new Person(“Jerry”,20);

coll.add§;

//1. contains(Object obj):判断当前集合中是否包含obj

boolean contains = coll.contains(123);

System.out.println(contains);//true

//当然contain()方法比较的不是地址，如创建了两个不同地址，相同内容的String，结果就返回了true。

//原因呢，就是因为String类中重写了equals方法，就是比较内容，所以这里返回true

//额外说一下，equals比较是从头到尾进行比较，比较多少次得看位置在哪里。

System.out.println(coll.contains(new String(“Tom”)));//true

//对于自己定义的类，如果自己没有重写equals方法，那么就是默认调用父类Object的方法，那就是用 == 判断 ， 不是用equals判断， 那就比较的是地址。

System.out.println(coll.contains(new Person(“hello”,22)));//false

System.out.println(coll.contains§);//true

//2. containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。

//Arrays.asList的作用是将数组转化为list。

Collection coll1 = Arrays.asList(123,456);

System.out.println(coll.containsAll(coll1));

}

}

class Person{

private String name;

private int age;

public Person() {

}

public Person(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public int getAge() {

return age;

}

public void setName(String name) {

this.name = name;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return “Person{” +

“name='” + name + ‘’’ +

“, age=” + age +

‘}’;

}

}

package com.holmes.java07;

import org.junit.Test;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

public class CollectionTest {

@Test

public void test2(){

//3. remove(Object obj):从当前集合中移除obj元素。

Collection coll = new ArrayList();

coll.add(123);

coll.add(456);

coll.add(new String(“Tom”));

coll.add(new Person(“hello”,22));

coll.add(false);

coll.remove(123);

System.out.println(coll);

//4. removeAll(Collection collName):从当前集合中移除collName中所有的元素

//意思就是：除去双方交集。

Collection coll1 = Arrays.asList(456, new String(“Tom”));

coll.removeAll(coll1);

System.out.println(coll);

}

@Test

public void test3(){

Collection coll = new ArrayList();

coll.add(123);

coll.add(456);

coll.add(new String(“Tom”));

coll.add(new Person(“hello”,22));

coll.add(false);

Collection coll1 = Arrays.asList(123,456,789);

//5. coll.retainAll(collName):取coll和collName的交集，并把交集返给当前集合(coll)

coll.retainAll(coll1);

System.out.println(coll);

//6. equals(Object obj):

Collection coll2 = new ArrayList();

coll2.add(new String(“Tom”));

coll2.add(123);

Collection coll3 = new ArrayList();

coll3.add(new String(“Tom”));

coll3.add(123);

System.out.println(coll2.equals(coll1));

//需要注意的是equals()方法对于String等类型，都是重写后的比较值，如果用的是Object类型的equals那就是比较地址。

//这样比较是要另外判断

System.out.println(coll3.equals(coll2));

}

}

3.2 集合转数组 和 数组转集合 的一些方法

集合转数组，数组转集合等等：

package com.holmes.java07;

import org.junit.Test;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.List;

public class CollectionTest3 {

@Test

public void test(){

Collection coll = new ArrayList();

coll.add(123);

coll.add(456);

coll.add(new String(“Tom”));

coll.add(new Person(“hello”,22));

coll.add(false);

//7. hashCode():返回当前对象的哈希值。

System.out.println(coll.hashCode());

//8. 集合 ==》 数组 toArray():

Object[] arr = coll.toArray();

for (int i=0;i<arr.length;i++){

System.out.println(arr[i]);

}

//9. 数组 ==》 集合 Arrays.asList() 调用Arrays类的静态方法asList():

List list = Arrays.asList(new String[]{“AA”, “BB”, “CC”});

System.out.println(list);//[AA, BB, CC]

//int这种写法会将123，456整体认为是一个元素

List ints = Arrays.asList(new int[]{123, 456});

System.out.println(ints);

System.out.println(ints.size());//1

//Integer包装类写法就不会

List ints2 = Arrays.asList(new Integer[]{123, 456});

System.out.println(ints2.size());

//再个就是传入两个对象，那就是两个元素，不能混淆！

List ints4 = Arrays.asList(new String[]{“abc”,“efg”},new String[]{“hig”,“kml”});

System.out.println(ints4);

System.out.println(ints4.size());

List ints3 = Arrays.asList(123,456);

System.out.println(ints3);

//9. iterator(): 返回Iterator接口的实例，用于遍历集合元素。

System.out.println(coll.iterator());

}

}

4. Iterator 遍历

============================================================================

4.1 使用 Iterator 遍历Collection

Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，自然实现了Collection接口的结合都有一个iterator()方法，用来返回一个实现了Iterator接口的对象。

在这里插入图片描述

Iterator接口的方法有三个：

  • hasNext()方法：该方法用来判断是否还有下一个元素。

  • next()方法：指针下移，将下移以后集合位置上的元素返回。

  • iterator.remove()方法：这个是迭代器的remove，它也可以删除集合中的元素，但不同于集合的remove方法，一定注意。

集合遍历一般如下：

package com.holmes.java07;

import org.junit.Test;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class Testset {

@Test

public void test(){

Collection col = new ArrayList();

col.add(123);

col.add(456);

col.add(new String(“江山如画”));

col.add(false);

//使用iterator遍历集合内容：

Iterator iterator = col.iterator();

while (iterator.hasNext()){

System.out.println(iterator.next());

}

//iterator的remove()方法：

Iterator iterator1= col.iterator();

while (iterator1.hasNext()){

Object obj = iterator1.next();

if (“江山如画”.equals(obj)){

//iterator.remove()方法：也可以移除集合中的元素

iterator1.remove();

}

}

System.out.println(col);

}

}

迭代器remove的两种错误用法：

  • 开始不能一上来就用remove，不然开始指针还没指向第一个集合元素，无法确定移除谁？

  • 再者就是调用了一次remove就不能调用第二次了，因为调用一次当前remove直接移除，再调用一次指针仍然指向已经移除的位置自然就会报错。

package com.holmes.java07;

import org.junit.Test;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class Testset {

@Test

public void test(){

Collection col = new ArrayList();

col.add(123);

col.add(456);

col.add(new String(“江山如画”));

col.add(false);

Iterator iterator= col.iterator();

//第一种情况：

//报错！java.lang.IllegalStateException

//while (iterator.hasNext()){

// iterator.remove();

// System.out.println(iterator.next());

//}

//第二种情况：

while (iterator.hasNext()){

iterator.remove();

System.out.println(iterator.next());

iterator.remove();//这里也是不对的！！报错！java.lang.IllegalStateException

}

}

}

迭代器执行原理：

在这里插入图片描述

4.2 使用foreach循环 遍历集合元素

通过for遍历集合：

在这里插入图片描述

同样也可以遍历数组：

在这里插入图片描述

5. Collection 子接口之一 list接口

========================================================================================

5.1 list接口的 具体类

list接口下，类定义下，元素存储有序，且可重复。

list接口下有三个类：

  • ArrayList类：作为List接口的主要实现类；线程不安全的，效率高。底层使用Object[] elementData存储。

  • LinkedList类：底层使用双向链表存储，对于频繁的插入，删除操作，使用此类效率比ArrayList要高。

  • Vector类：作为List接口的古老实现类；线程安全的，效率低。底层使用Object[] elementData存储。

在这里插入图片描述

5.2 ArrayList类 原理分析

ArrayList类：作为List接口的主要实现类；线程不安全的，效率高。底层使用Object[] elementData存储。

ArrayList源码分析：

jdk 7：

在这里插入图片描述

jdk 8：

在这里插入图片描述

5.3 LinkedList类 原理分析

LinkedList类：底层使用双向链表存储，对于频繁的插入，删除操作，使用此类效率比ArrayList要高。

因为双向链式，修改插入起来更加灵活。

在这里插入图片描述

5.4 Vector类 原理分析

Vector类：作为List接口的古老实现类；线程安全的，效率低。底层使用Object[] elementData存储。

在这里插入图片描述

5.5 list接口的 常用方法

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class Testset {

@Test

public void test(){

ArrayList list = new ArrayList();

list.add(123);

list.add(456);

list.add(new String(“江山如画”));

list.add(false);

//list.add(int index , Object element):在index位置插入element元素

list.add(1,“AAA”);

System.out.println(list);

//list.addAll(int index , Collection elements):从index位置开始将elements中的所有元素添加刀集合中

List list2 = Arrays.asList(1,2,3,4);

list.addAll(3,list2);

System.out.println(list);

//list.indexOf(Object obj):查询obj在集合中的位置返回索引。

int index = list.indexOf(456);

System.out.println(index);

//list.lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。

list.add(0,“江山如画”);

int index2 = list.lastIndexOf(“江山如画”);

System.out.println(index2);

//list.remove(int index)方法:移除指定index位置的元素，并返回此元素。

Object obj = list.remove(2);

System.out.println(obj);

System.out.println(list);

//list.set(int index , Object element)方法：设置指定index位置的元素为element。

list.set(0,“三国演义”);

System.out.println(list);

//list.subList(int fromIndex , int toIndex):返回从fromIndex到toIndex位置的子集合。

List list1 = list.subList(1, 3);

System.out.println(list1);

//list.size():返回当前集合长度

System.out.println(list.size());

//list.get(Int index):返回当前index位置的元素

System.out.println(list.get(0));

}

}

6. Collection 子接口之二 set接口

=======================================================================================

6.1 Set接口 介绍

set接口是Colection的子接口，它不允许包含相同的元素，同时它是无序的。

Set接口的实现类：

  • HashSet：作为Set接口的主要实现类；线程不安全，可以存储null值。

LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历。

  • TreeSet：可以按照添加对象的指定属性，进行排序。

Set接口中没有额外定义的新方法，使用的都是Collection中声明过的方法。

Set接口的无序性：

  • 无序性 不等于随机，存储数据在底层不是按照索引添加来确定顺序，而是根据数据的哈希值确定。

Set接口的不可重复性：

  • 保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个。

add()方法添加元素的原理如下：(重要)

它是先查看存放位置是否相同，不相同直接添加；位置相同的话，就比较hash值相同不相同，hash值不相同就添加；如果hash值相同的话，再比较equals想不想同，不想相同就添加。

在这里插入图片描述

Set实现类HashSet的扩容方式：

在这里插入图片描述

6.2 Set中重写hashCode() 和 equals()方法

hashCode()方法作用详解：

在这里插入图片描述

Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即 “相等的对象必须具有相等的散列码” 。

在这里插入图片描述

平时，我们创建的类，最好通过系统直接重写equals()和hashCode()方法：

在这里插入图片描述

class Person01 {

private String name;

private int age;

public Person01(String name, int age) {

this.name = name;

this.age = age;

}

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

Person01 person01 = (Person01) o;

return age == person01.age && Objects.equals(name, person01.name);

}

@Override

public int hashCode() {

return Objects.hash(name, age);

}

}

6.3 HashSet 和 LinkedHashSet(HashSet的子类)

HashSet：作为Set接口的主要实现类；线程不安全，可以存储null值。

LinkedHashSet：作为HashSet的子类，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。

优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet。

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class SetTest {

@Test

public void test(){

Set set = new HashSet();

set.add(456);

set.add(123);

set.add(“AA”);

set.add(“CC”);

System.out.println(set);

Set set2 = new LinkedHashSet();

set2.add(456);

set2.add(123);

set2.add(“AA”);

set2.add(“CC”);

System.out.println(set2);

}

}

6.4 TreeSet 的 自然排序 和 定制排序

首先，TreeSet不能添加不同类的对象！不然报错java.lang.ClassCastException。只能添加相同类的属性。

TreeSet遍历要配合重写toString方法，不然返回的就是地址值。

6.4.1 TreeSet 自然排序

自然排序就要对TreeSet中的类，让该类实现comparable接口，重写compareTo方法和toString()方法。

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class SetTest {

@Test

public void test(){

TreeSet set = new TreeSet();

set.add(new User(“Tom”,22));

set.add(new User(“Aerry”,24));

set.add(new User(“Mim”,49));

set.add(new User(“Mim”,36));

set.add(new User(“Jack”,12));

Iterator iterator = set.iterator();

while (iterator.hasNext()){

System.out.println(iterator.next());

}

}

}

class User implements Comparable{

private String name;

private int age;

public User(String name, int age) {

this.name = name;

this.age = age;

}

@Override

public int compareTo(Object o) {

//按照姓名从小到大排序

if (o instanceof User){

User user = (User)o;

int compare = this.name.compareTo(user.name);

//如果姓名大小相同，则就比较年龄

if (compare != 0){

return compare;

}else {

//这里有Integer的compare比较方法牢记！！

return Integer.compare(this.age,user.age);

}

}else {

throw new RuntimeException(“输入的类型不匹配”);

}

}

@Override

public String toString() {

return “User{” +

“name='” + name + ‘’’ +

“, age=” + age +

‘}’;

}

}

6.4.2 TreeSet 定制排序

定制排序就是定义comparator作为参数，传给TreeSet。

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class SetTest {

@Test

public void test2(){

Comparator comparator = new Comparator() {

@Override

public int compare(Object o1, Object o2) {

//按照年龄排序：

if (o1 instanceof User && o2 instanceof User){

User u1 = (User) o1;

User u2 = (User) o2;

return Integer.compare(u1.getAge(),u2.getAge());

}else {

throw new RuntimeException(“输入的数据类型不匹配”);

}

}

};

TreeSet set = new TreeSet(comparator);

set.add(new User(“Tom”,22));

set.add(new User(“Aerry”,24));

set.add(new User(“Mim”,49));

set.add(new User(“Mim”,36));

set.add(new User(“Jack”,12));

Iterator iterator = set.iterator();

while (iterator.hasNext()){

System.out.println(iterator.next());

}

}

}

class User {

private String name;

private int age;

public User(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return “User{” +

“name='” + name + ‘’’ +

“, age=” + age +

‘}’;

}

}

7. Map接口

======================================================================

7.1 Map接口 实现类 和 结构原理

Map接口：双列数据，存储key-value对的数据 ， 类似于数学中的y和x对应。

Map接口实现类：

  • HashMap：作为Map的主要实现类；线程不安全的，效率高；能存储null的key和value。

LinkedHashMap：它是HashMap的子类，在原有的HashMap底层结构基础上，添加一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。

  • Hashtable：(注意这里时小写t) 作为古老的实现类；线程安全的，效率低；不能存储null的key和value。

Properties:常用来处理配置文件，key和value都是String类型。(例如jdbc的Properties文件)。

  • TreeMap：保证按照添加的key-value对进行排序，实现排序遍历此时要考虑key的自然排序或定制排序。

Map 的结构原理：

  • Map中的key：无序的，不可重复的，使用Set存储所有的key。

  • Map中的value：无序的，可重复的，使用Collection存储所有value。

  • 一个键值对：key-value构成一个Entry对象。Map中的entry：无序的，不可重复的，使用Set存储所有的entry。

7.2 HashMap的底层实现原理？

JDK 7：

在这里插入图片描述

扩容问题，既然涉及到数组，必然有扩容的问题，HashMap默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。

JDK 8：

在这里插入图片描述

LinkedHashMap的底层实现原理？

在这里插入图片描述

7.3 Map接口一些常用的 方法

Map的基本操作方法：

package com.holmes.java07;

import org.junit.Test;

import java.util.HashMap;

import java.util.Map;

public class MapTest {

@Test

public void test(){

Map map = new HashMap();

//map.put(Object key , Object value)方法：添加和修改，key，value。

map.put(“AA”,123);

map.put(“BB”,456);

map.put(“CC”,789);

//修改

map.put(“AA”,342);

System.out.println(map);

Map map2 = new HashMap();

map2.put(“KK”,453);

map2.put(“oo”,2342);

//map.putAll(Map map)方法:将m中的所有key—value对存放到当前map中。

map.putAll(map2);

System.out.println(map);

//map.remove(Object key)方法:移除指定key的key-value对，并返回value。

Object value = map.remove(“CC”);

System.out.println(value);

System.out.println(map);

//map.clear()方法:清空当前map中的所有数据。

map.clear();//注意！清空后不是null

System.out.println(map);

}

@Test

public void test2(){

Map map = new HashMap();

map.put(“AA”,123);

map.put(“BB”,456);

map.put(“CC”,789);

//map.get(Object key)方法:获取指定key对应的value

System.out.println(map.get(“CC”));

//map.containsKey(Object key)方法：是否包含指定的key

boolean isExist = map.containsKey(“BB”);

System.out.println(isExist);

//map.containsValue(Object value)方法：是否包含指定的value

boolean isExist2 = map.containsValue(456);

System.out.println(isExist2);

//map.size()方法：返回map中key-value对的个数

System.out.println(map.size());

//map.isEmpty()方法：判断当前map是否为空

System.out.println(map.isEmpty());

//map.equals(Object obj)方法：判断当前map和参数对象obj是否相等

}

}

元视图的方法：

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class MapTest {

@Test

public void test(){

Map map = new HashMap();

//map.put(Object key , Object value)方法：添加和修改，key，value。

map.put(“AA”,123);

map.put(“BB”,456);

map.put(“CC”,789);

//修改

map.put(“AA”,342);

System.out.println(map);

Map map2 = new HashMap();

map2.put(“KK”,453);

map2.put(“oo”,2342);

//map.putAll(Map map)方法:将m中的所有key—value对存放到当前map中。

map.putAll(map2);

System.out.println(map);

//map.remove(Object key)方法:移除指定key的key-value对，并返回value。

Object value = map.remove(“CC”);

System.out.println(value);

System.out.println(map);

//map.clear()方法:清空当前map中的所有数据。

map.clear();//注意！清空后不是null

System.out.println(map);

}

@Test

public void test2(){

Map map = new HashMap();

map.put(“AA”,123);

map.put(“BB”,456);

map.put(“CC”,789);

//map.get(Object key)方法:获取指定key对应的value

System.out.println(map.get(“CC”));

//map.containsKey(Object key)方法：是否包含指定的key

boolean isExist = map.containsKey(“BB”);

System.out.println(isExist);

//map.containsValue(Object value)方法：是否包含指定的value

boolean isExist2 = map.containsValue(456);

System.out.println(isExist2);

//map.size()方法：返回map中key-value对的个数

System.out.println(map.size());

//map.isEmpty()方法：判断当前map是否为空

System.out.println(map.isEmpty());

//map.equals(Object obj)方法：判断当前map和参数对象obj是否相等

}

@Test

public void test03(){

Map map = new HashMap();

map.put(“AA”,123);

map.put(“BB”,456);

map.put(“CC”,789);

//遍历所有的key集：keySet()

Set set = map.keySet();

Iterator iterator = set.iterator();

while (iterator.hasNext()){

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

img

总结

总体来说，如果你想转行从事程序员的工作，Java开发一定可以作为你的第一选择。但是不管你选择什么编程语言，提升自己的硬件实力才是拿高薪的唯一手段。

如果你以这份学习路线来学习，你会有一个比较系统化的知识网络，也不至于把知识学习得很零散。我个人是完全不建议刚开始就看《Java编程思想》、《Java核心技术》这些书籍，看完你肯定会放弃学习。建议可以看一些视频来学习，当自己能上手再买这些书看又是非常有收获的事了。


《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
est2(){

Map map = new HashMap();

map.put(“AA”,123);

map.put(“BB”,456);

map.put(“CC”,789);

//map.get(Object key)方法:获取指定key对应的value

System.out.println(map.get(“CC”));

//map.containsKey(Object key)方法：是否包含指定的key

boolean isExist = map.containsKey(“BB”);

System.out.println(isExist);

//map.containsValue(Object value)方法：是否包含指定的value

boolean isExist2 = map.containsValue(456);

System.out.println(isExist2);

//map.size()方法：返回map中key-value对的个数

System.out.println(map.size());

//map.isEmpty()方法：判断当前map是否为空

System.out.println(map.isEmpty());

//map.equals(Object obj)方法：判断当前map和参数对象obj是否相等

}

@Test

public void test03(){

Map map = new HashMap();

map.put(“AA”,123);

map.put(“BB”,456);

map.put(“CC”,789);

//遍历所有的key集：keySet()

Set set = map.keySet();

Iterator iterator = set.iterator();

while (iterator.hasNext()){

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-Ylsu2r2r-1713111437349)]

[外链图片转存中…(img-7T3gQSpB-1713111437350)]

[外链图片转存中…(img-mMmxUEoE-1713111437350)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

img

总结

总体来说，如果你想转行从事程序员的工作，Java开发一定可以作为你的第一选择。但是不管你选择什么编程语言，提升自己的硬件实力才是拿高薪的唯一手段。

如果你以这份学习路线来学习，你会有一个比较系统化的知识网络，也不至于把知识学习得很零散。我个人是完全不建议刚开始就看《Java编程思想》、《Java核心技术》这些书籍，看完你肯定会放弃学习。建议可以看一些视频来学习，当自己能上手再买这些书看又是非常有收获的事了。

[外链图片转存中…(img-34hxdVsH-1713111437351)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

Z70czd
关注
专栏目录
java基础知识点笔记
03-27
java基础知识点笔记
java各知识点详细总结(毕向东笔记整理)
01-30
java各知识点详细总结(毕向东笔记整理)。第一章：编程基础 3-11 第二章：数组 11 -31 第三章：面向对象程序开发 31 -74 第四章：异常机制 74 -89 第五章：多线程技术 89 -122122122 第六章：常用类 API 122API 122 ...
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java基础知识总结（超详细整理）
热门推荐
龙源IT 的博客
07-17 31万+
Java语言的特点，1.面向对象(OOP)就是Java语言的基础，也是Java语言的重要特性。面向对象的概念：生活中的一切事物都可以被称之为对象，生活中随处可见的事物就是一个对象，我们可以将这些事物的状态特征（属性）以及行为特征（方法）提取并出来，并以固定的形式表示。 2.简单好用，Java语言是由C和C++演变而来的，它省略了C语言中所有的难以理解、容易混淆的特性（比如指针），变得更加严谨、简洁、易使用。 3.健壮性、Java的安全检查机制，将许多程序中的错误扼杀在摇蓝之中。 另外，在
Java基础知识之笔记总结分享（超详细）
iswitched的博客
05-03 7万+
给大家分享一篇我在学习java过程中的关于java基础部分的笔记，包含面向对象思想，集合，接口，抽象方法等等详细知识点
JAVA基础知识点总结
sen_sen97的博客
07-11 1万+
Java 是一门面向对象的编程语言。 语言特点：面向对象，平台无关性，支持多线程，编译与解释并存JVM：Java Virtual Machine，Java 虚拟机。 JRE： Java 运⾏时环境。 JDK: Java Development Kit，它是功能⻬全的 Java SDK。 JDK 包含 JRE，JRE 包含 JVM。Java 程序从源代码到运行主要有三步： 编译：将我们的代码（.java）编译成虚拟机可以识别理解的字节码(.class) 解释：虚拟机执行 Java 字节码，将字节码翻译成机器能
超全！JAVA基础知识点总结
Abcd6578787_的博客
07-29 1万+
每部分内容会重点写一些常见知识点，方便复习和记忆，但并不是全部内容。
Java 基础知识点 笔记总结 (十)
探索技术与实践的旅程，分享编程经验与工具使用心得，助力开发者提升技能。
12-24 4054
1. 泛型 定义 2. 泛型 的小细节 3. 泛型 自定义泛型 4. 泛型 自定义泛型注意点 5. 泛型方法 6. 泛型 继承注意点 7. 泛型 通配符？ 8. 泛型 有限制条件的通配符？ 9. File类 9.1 File类的使用 9.2 file类的常用方法 9.3 file类 总结 10. IO 流 11. IO流 体系对象 12. IO流 的使用 12.1 IO的 读操作 12.1 IO的 写操作 13. 缓冲流 的使用 14. 转换流 InputStreamReader 和 OutputStrea
Java基础知识点梳理（详细）
程序员小辰的代码小窝
03-08 9万+
Java基础知识点全面梳理（详细）
Java基础知识点总结归纳，超级全面！（2021版）
Java笔记
05-03 10万+
凯哥今天看了网上好多关于Java基础知识点汇总的博客，but，感觉都不尽如人意，要么不全面，要么不准确，要么排版太乱了！ 所以今天花了一天时间整理了一份Java基础知识点总结归纳，超级全面！希望对大家有帮助哈~ 由于本文篇幅过长，博主为了方便大家阅读和收藏，特意将本文转成了一份PDF版的文档。 需要PDF版的朋友可以关注微信公众号：Java团长，发送“基础知识”即可获取哈~ 一、Java概述 1、何为编程 编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到结果的过程..
Java 基础知识点 笔记总结 (八)
探索技术与实践的旅程，分享编程经验与工具使用心得，助力开发者提升技能。
11-22 6861
1. 枚举类 介绍 2. JDK5.0之前 自定义枚举类 3. JDK5.0之后 使用enum关键字 定义枚举类 4. enum类中的常用方法 5. 使用enum关键字定义的枚举类 实现接口的情况 6. 注解(Annotation) 7. 注解 起源 功能 8. 三个JDK内置基本注解 8.1 @Override注解 8.2 @Deprecated注解 8.3 @SuppressWarning注解 9. 自定义注解 10. JDK中的元注解 10.1 什么是元注解？ 10.2 @Retention 元注解
Java 基础知识总结（下）-王者笔记《收藏版》
java李阳勇的博客
07-27 5万+
内存是计算机的重要部件之⼀。它是外存与CPU进⾏沟通的桥梁，计算机中所有程序的运⾏都在内存中进⾏。内存性能的强弱影响计算机整体发挥的⽔平。内存(Memory)也称内存储器和主存储器，它用于暂时存放CPU中的运 算数据，与硬盘等外部存储器交换的数据。只要计算机开始运⾏，操作系统就会把需要运算的数据从内存调到 CPU中进⾏运算。当运算完成，CPU将结果传送出来。内存的运⾏也决定计算机整体运⾏快慢的程度。内存条由内存芯片、电路板、⾦⼿指等部分组成。电脑硬盘是计算机最主要的存储设备。
java基础总结大全(笔记).pdf
02-28
Java基础总结大全涵盖了Java编程语言的核心概念，从JVM、JRE和JDK的区别，到环境变量的设置，再到变量的定义和类型转换，深入浅出地讲解了Java的基础知识。 1. JVM、JRE和JDK： - JVM（Java Virtual Machine）是...
Java面试笔记 225道Java面试题JAVA面试基础知识点总结Java数据结构题笔试WORD资料汇总(19个).zip
05-15
Java面试笔记 225道Java面试题JAVA面试基础知识点总结Java数据结构题 JAVA笔试面试WORD资料汇总(19个): 2014年最新Java笔试题及答案.docx 225道Java面试题 学会了Java面试随你问.docx Ant和Maven的作用是什么？两者...
尚硅谷JAVA基础笔记吐血整理
02-03
【JAVA语言概述】 Java是一种跨平台的面向对象的编程语言，由Sun Microsystems开发，现由Oracle公司维护。它的设计目标是实现“一次编写，到处...这些知识点是学习Java编程的基础，对于理解和编写Java代码至关重要。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 921
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 353
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 700
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1016
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
Java基础知识点总结
本文档是java基础笔记的总结，涵盖了java语法基础到API的所有知识点。本文档适合初学者作为参考，内容纯粹、精华、简洁易懂。 1. 类变量：类变量是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值