• Java高级学习栈（史上最详细的整合）

    目录

    一：集合

    1.什么是集合

    2.List的特点

    3.ArrayList和LinkedList的区别

    4.set的提点

    5.map的特点

    6.ArrayList

    7.泛型

    7.1.不带泛型

    7.2带泛型（公司用）

    8.LinkedList实战

    9.HashMap实战

    9.HashSet实战

    二、  Api

    1.枚举 

    2.包装类

    2.1基本数据类型转换为包装类进行算数运算

    2.2将包装类转化为数据类型

    2.3intValue（）

    2.4toString（）基本类型转化为字符串类型

    一：集合

    1.什么是集合

    定义：通俗的说，集合就是一个放数据的容器，准确的说是放数据对象引用的容器。

    集合可以分为两大体系，一个是Collection，一个是 Map。Coection接口又分别被List和Set继承，List被AbstractList实现，然后分为3个子类，ArrayList，LinkList和Vector。Set被AbstractSet实现，又分为HashSet和TreeSet。而Map衍生出的集合分为HashMap,HashTable和TreeMap。

    Coection接口：

          1.定义的是所有单列集合中共性的方法。

          2.所有的单列集合都可以使用共性的方法。

          3.没有索引的方法。

    Map接口：

         1.双列数据，保存具有映射关系“key-value对”的集合。

     常用功能：

    java.util.Collection接口

    所有单列结合顶层的接口，里面定义了所有单列集合共性的方法。 任意的单列集合都可以使用Collection接口的方法。

    共性的方法：

    public boolean add(E e);把给定的对象添加到当前集合中

    public void clear();清空集合中的所有元素

    public boolean remove(E e);把给定的对象在当前集合中删除

    public boolean contains(E e);判断当前的集合中是否包含给定的对象

    public boolean isEmpty(E e);判断当前集合是否为空

    public int size();返回元素中集合的个数

    public Object[] toArray();把集合中的当前元素，存储到数组中

    1. package Demo01;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Collection;
    5.  
    6. /*
    7. @Author 代码贩子、  --南京邮电大学
    8.  */
    9. /*
    10.     java.util.Collection接口
    11.     所有单列结合顶层的接口，里面定义了所有单列集合共性的方法。
    12.     任意的单列集合都可以使用Collection接口的方法。
    13.     共性的方法：
    14.     public boolean add(E e);把给定的对象添加到当前集合中
    15.     public void clear();清空集合中的所有元素
    16.     public boolean remove(E e);把给定的对象在当前集合中删除
    17.     public boolean contains(E e);判断当前的集合中是否包含给定的对象
    18.     public boolean isEmpty(E e);判断当前集合是否为空
    19.     public int size();返回元素中集合的个数
    20.     public Object[] toArray();把集合中的当前元素，存储到数组中
    21.  */
    22. public class jihe {
    23.     public static void main(String[] args) {
    24.         //创建集合对象，可以使用多态
    25.         Collection<String> collection = new ArrayList<>();
    26.         System.out.println(collection);//重写了toString方法，打印的是空字符串
    27.         //public boolean add(E e);把给定的对象添加到当前集合中
    28.         //返回值是一个布尔值，一般都返回true，所以可以不用接收
    29.         boolean b1 = collection.add("张三");
    30.         System.out.println(b1);//以后不用接收这个返回值，因为没有意义
    31.         collection.add("李四");
    32.         collection.add("王五");
    33.         System.out.println(collection);
    34.         //public boolean remove(E e);把给定的对象在当前集合中删除
    35.         //返回值是一个布尔值，集合中存在元素，删除元素，返回true
    36.         //集合中不存在元素，删除失败，返回false
    37.         boolean b2 = collection.remove("田七");
    38.         collection.remove("李四");
    39.         System.out.println(b2);
    40.         System.out.println(collection);
    41.         //public boolean contains(E e);判断当前的集合中是否包含给定的对象
    42.         //返回值是一个布尔值，集合中存在元素，包含元素，返回true
    43.         //集合中不存在元素，不包含元素，返回false
    44.         boolean b3 = collection.contains("田七");
    45.         collection.contains("张三");
    46.         System.out.println(b3);
    47.         System.out.println(collection);
    48.         //public boolean isEmpty(E e);判断当前集合是否为空
    49.         //返回值是一个布尔值，集合为空，返回true
    50.         //集合不为空，返回false
    51.         boolean b4 = collection.isEmpty();
    52.         System.out.println(b4);
    53.         System.out.println(collection);
    54.         //public int size();返回元素中集合的个数
    55.         int size = collection.size();
    56.         System.out.println(size);
    57.         //public Object[] toArray();把集合中的当前元素，存储到数组中
    58.         Object[] arr = collection.toArray();//Object可以存储任意的元素，可以把集合编程一个数组
    59.         for (int i = 0; i <arr.length ; i++) {
    60.             System.out.println(arr[i]);
    61.         }
    62.         //public void clear();清空集合中的所有元素
    63.         collection.clear();
    64.         System.out.println(collection);
    65.         System.out.println(collection.isEmpty());
    66.     }
    67. }

    2.List的特点

    1.有序的集合（存储和取出元素的顺序相同）。

    2.允许存储重复的元素。

    3.有索引，可以使用普通的for循环来遍历

    3.ArrayList和LinkedList的区别

    二者都线程不安全。ArrayList实现了基于动态数组的数据结构，LinkList是基于链表的数据结构。对于随机访问的set和get的方法，ArrayList要比LinkList更加优秀，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。

    4.set的提点

    无序，不重复。

    5.map的特点

    无序、以键值对的形式添加元素，键不能重复，值可以重复。它没有继承Collection接口。

    6.ArrayList

    7.泛型

    泛型是一种未知的数据类型，当我们不知道数据类型是什么的时候，可以使用泛型。

    泛型可以看作是一个变量，用来接收数据类型。

    7.1.不带泛型

    好处：可以存储任何的数据类型。

    坏处：在需要使用存储类型的时候需要向下转型，如果没有instanceof就容易报错ClassCastException。

    7.2带泛型（公司用）

    好处：1.将运行期可能出现的问题提前到编译期，如果ArrayList的泛型是String就只能存储String类型。存储别的类型就会报错。

              2.可以使用泛型中数据特有的方法。

    坏处：只能存储一种数据类型。

    8.LinkedList实战

    1. package Demo02;
    2.  
    3. public class New {
    4.     private Integer id;
    5.     private String name;
    6.     private String title;
    7.  
    8.     public New() {
    9.     }
    10.     public New(Integer id, String name, String title) {
    11.         this.id = id;
    12.         this.name = name;
    13.         this.title = title;
    14.     }
    15.  
    16.     public Integer getId() {
    17.         return id;
    18.     }
    19.  
    20.     public void setId(Integer id) {
    21.         this.id = id;
    22.     }
    23.  
    24.     public String getName() {
    25.         return name;
    26.     }
    27.  
    28.     public void setName(String name) {
    29.         this.name = name;
    30.     }
    31.  
    32.     public String getTitle() {
    33.         return title;
    34.     }
    35.  
    36.     public void setTitle(String title) {
    37.         this.title = title;
    38.     }
    39. }
    40. package Demo02;
    41.  
    42. import java.util.LinkedList;
    43.  
    44. public class psvm {
    45.     /*
    46.     LinkedList添加数据的方法
    47.      */
    48.     public static void main(String[] args) {
    49.         New New1  = new New(1,"张三","老板");
    50.         New New2  = new New(2,"李四","老板");
    51.         New New3  = new New(3,"王五","老板");
    52.         New New4  = new New(4,"赵六","老板");
    53.         New New5  = new New(5,"田七","老板");
    54.         LinkedList<New> linkedList = new LinkedList<New>();
    55.         linkedList.add(New1);
    56.         linkedList.add(New2);
    57.         linkedList.add(New3);
    58.         linkedList.add(New4);
    59.         linkedList.add(New5);
    60.         System.out.println(linkedList.size());
    61.         /*
    62.         LinkedList删除数据的方法
    63.          */
    64.         //精准定位角标来进行删除
    65.         linkedList.remove(2);
    66.         //删除第一条数据
    67.         linkedList.removeFirst();
    68.         //删除最后一条数据
    69.         linkedList.removeLast();
    70.         System.out.println(linkedList.size());
    71.         /*
    72.          LinkedList查询数据的方法
    73.          */
    74.         //查询第一条数据
    75.         linkedList.getFirst().getName();
    76.         //查询最后一条数据
    77.         linkedList.getLast().getName();
    78.         //for循环遍历数据
    79. //        for (int i = 0; i <linkedList.size() ; i++) {
    80. //            System.out.println(linkedList.get(i).getName());
    81. //        }
    82.         //增强for遍历数据
    83.         for (New news: linkedList){
    84.             System.out.println("Id"+news.getId()+"name"+news.getName()+"title"+news.getTitle());
    85.         }
    86.     }
    87. }

    9.HashMap实战

    特点：键值存储。

    1. package Demo02;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Iterator;
    5. import java.util.Set;
    6.  
    7. public class psvm {
    8.     /*
    9.     LinkedList添加数据的方法
    10.      */
    11.     public static void main(String[] args) {
    12.         //1.实例化HashMap容器
    13.         HashMap<String,Object> hashMap= new HashMap<String,Object>();
    14.         //2.给HashMap容器添加键值对（添加数据）
    15.         hashMap.put("a","aaa");
    16.         hashMap.put("1","bbb");
    17.         hashMap.put("2","ccc");
    18.         //3使用增强for来遍历HashMap
    19.         //3.1keySet（）代表获取HashMap容器中的所有键的集合
    20.         Set<String> sets= hashMap.keySet();
    21.         System.out.println(sets);
    22.         //3.2增强for循环遍历sets集合将键和值循环遍历出来而得到真正的键
    23.         /*
    24.         把HashMap键里面的集合全部的提取出来，通过遍历k就可以得到我们对应的值
    25.          */
    26. //        for (String s:sets){
    27. //            System.out.println(s);
    28. //        }
    29.         //4.使用迭代器循环遍历HashMap获取键和值
    30.         //4.1调用sets的iterator()得到Iterator迭代器
    31.         Iterator<String> iterator = sets.iterator();
    32.         //4.2通过hasNext()循环判断HashMap容器中是否有下一个值
    33.         while (iterator.hasNext()){
    34.             //4.3如果有则调用迭代器next()获取对应的值，这个值就是key键
    35.             String key = iterator.next();
    36.             //4.4得到键之后，调用HashMap容器的get（）方法获取对应的key键的value值
    37.             System.out.println("key："+key+";"+"value:"+hashMap.get(key));
    38.         }
    39.     }
    40. }

    9.HashSet实战

    特点：唯一，无序。

    1. package Demo03;
    2. import java.util.HashSet;
    3. import java.util.Iterator;
    4.  
    5. public class Demo03 {
    6.     public static void main(String[] args) {
    7.         //1.实例化HashSet容器
    8.        HashSet<String> sets = new HashSet<String>();
    9.         //2.给HashSet容器添加键值对（添加数据）
    10.        sets.add("aaa");
    11.        sets.add("bbb");
    12.        sets.add("ccc");
    13.         //3.1keySet（）代表获取HashSet容器中的所有键的集合
    14.        Iterator<String> its = sets.iterator();
    15.         //4.使用迭代器循环遍历HashSet获取键
    16.         //4.1调用sets的iterator()得到Iterator迭代器
    17.        while (its.hasNext()){
    18.            //4.2如果有则调用迭代器next()获取对应的值，这个值就是key键
    19.            String key = its.next();
    20.            //4.3得到键之后，调用HashSet容器的get（）方法获取对应的key键
    21.            System.out.println("key"+key);
    22.        }
    23.     }
    24. }

    小练习1：遍历List>

    1. package Demo04;
    2.  
    3. import java.util.*;
    4.  
    5. public class Demo04 {
    6.     public static void main(String[] args) {
    7.         //1.准备泛型里的数据
    8.         HashMap<String,Object> map = new HashMap<String,Object>();
    9.         map.put("a","1");
    10.         map.put("b","2");
    11.         map.put("c","3");
    12.         //2.创建容器ArrayList<Map<String,Object>>
    13.         ArrayList<Map<String,Object>> list= new ArrayList>();
    14.         //3.准备数据塞入容器中
    15.         list.add(map);
    16.         //4.遍历ArrayList（从外往里遍历）
    17.         for (Map<String,Object> mm :list){
    18.             //System.out.println(mm);
    19.             //5.获取mm的HashMap容器中的键集合
    20.             Set<String> sets = mm.keySet();
    21.             //6.获取迭代器
    22.             Iterator<String> its = sets.iterator();
    23.             //7.循环遍历输出
    24.             while (its.hasNext()){
    25.                 String key =  its.next();
    26.                 System.out.println("key："+key+";"+"value:"+mm.get(key));
    27.             }
    28.         }
    29.     }
    30. }

    小练习2：遍历Map>

    1. package Demo05;
    2.  
    3.  
    4. import java.util.HashMap;
    5. import java.util.Iterator;
    6. import java.util.Map;
    7. import java.util.Set;
    8.  
    9. public class Demo05 {
    10.     public static void main(String[] args) {
    11.     /*
    12.     new后面的Map<String,Object>是一个类型
    13.     放在外面一定是实现类
    14.     数据应该是Map<String,Object>
    15.      */
    16.         //1.准备数据
    17.         Map<String,Object> m1 = new HashMap<String,Object>();
    18.         m1.put("a","1");
    19.         m1.put("b","2");
    20.         m1.put("c","3");
    21.         Map<String,Object> m2 = new HashMap<String,Object>();
    22.         m2.put("aa","11");
    23.         m2.put("bb","22");
    24.         m2.put("cc","33");
    25.         Map<String,Object> m3 = new HashMap<String,Object>();
    26.         m3.put("aaa","111");
    27.         m3.put("bbb","222");
    28.         m3.put("ccc","333");
    29.         //2.实例化Map<String, Map<String, Object>>()容器
    30.         Map<String, Map<String, Object>> map = new HashMap>();
    31.         //3.给容器塞值
    32.         map.put("aaaa",m1);
    33.         map.put("bbbb",m2);
    34.         map.put("cccc",m2);
    35.         //4.获取外层的Map容器
    36.         //4.1获取外层Map容器的key键集合
    37.         Set<String> sets = map.keySet();
    38.         //4.2获取外层Map容器的游标卡尺
    39.         Iterator<String> its = sets.iterator();
    40.         //4.3通过游标卡尺循环遍历外层Map
    41.         while (its.hasNext()){
    42.             //4.4通过游标卡尺获取外层Map的key键集合
    43.             String key = its.next();
    44.             //4.5 打印输出外层Map的key键集合以及value值
    45.             System.out.println("外层key："+key);
    46.             //5.遍历内层的Map容器
    47.             Map<String, Object> map1= map.get(key);
    48.             //5.1获取内层Map容器的key键集合
    49.             Set<String> setss = map1.keySet();
    50.             //5.2获取内层Map容器的游标卡尺
    51.             Iterator<String> itss = setss.iterator();
    52.             //5.3通过游标卡尺循环遍历内层Map
    53.             while (itss.hasNext()){
    54.                 //5.4通过游标卡尺获取内层Map的key键集合
    55.                String key1 = itss.next();
    56.                //5.5打印输出内层Map的key键集合以及value值
    57.                 System.out.println("内层key："+key1+"内层value："+map1.get(key1));
    58.             }
    59.         }
    60.     }
    61. }

    二、  Api

    老外写的一些类，类中有许多的方法。

    1.枚举 

    关键字：enum

    使用非枚举方式实现对Student类中的SEX属性赋值

    1. package Demo06;
    2.  
    3. public class Text {
    4.     public static void main(String[] args) {
    5.         Student student = new Student();
    6.         student.setSex("女");
    7.         System.out.println(student.getSex());
    8.         student.setSex("男女");//这里及有问题了 也不是人妖
    9.         /*
    10.         想要解决这个问题我们可以将他作为一个常量来进行定义、
    11.         但是这样做就不能进行多次赋值
    12.         private static final String SEX="男";
    13.          */
    14.         System.out.println(student.getSex());
    15.     }
    16. }
    17. package Demo06;
    18.  
    19. public class Student {
    20.     private String Sex;
    21.     public String getSex(){
    22.         return Sex;
    23.     }
    24.     public void setSex(String sex){
    25.         this.Sex = sex;
    26.     }
    27. }

    采用枚举的方式进行解决

    1. package Demo06;
    2.  
    3. public enum  Gender {
    4.     男,女
    5. }
    6. package Demo06;
    7.  
    8. public class Student {
    9.     private Gender Sex;
    10.  
    11.     public Gender getSex() {
    12.         return Sex;
    13.     }
    14.  
    15.     public void setSex(Gender sex) {
    16.         Sex = sex;
    17.     }
    18. }
    19. package Demo06;
    20.  
    21. public class Text {
    22.     public static void main(String[] args) {
    23.         Student student = new Student();
    24.         student.setSex(Gender.女);
    25.         System.out.println(student.getSex());
    26.         student.setSex(Gender.男);
    27.         System.out.println(student.getSex());
    28.         student.setSex("FALSE");//这里就报错了
    29.     }
    30. }

    2.包装类

    定义：所有的包装类在java.lang包中都有一个相应的包装类。

    作用：包装类提供一系列的实用方法，集合不允许存放基本的数据类型，要进行数字的存放时，要使用包装类型。（比如 ArrayList<> arrayList= new ArryList<>;<>l里面要么放Steing类型，要么放包装类型，想要放基本类型就要继续宁包装）.

    2.1基本数据类型转换为包装类进行算数运算

    1. package Demo07;
    2.  
    3. public class demo07 {
    4.     public static void main(String[] args) {
    5.         int a = 1;
    6.         Integer a_new = new Integer(a);
    7.         System.out.println(a_new);
    8.         byte b = 2;
    9.         Byte b_new = new Byte(b);
    10.         System.out.println(b_new);
    11.         short c = 3;
    12.         short c_new = c;
    13.         System.out.println(c_new);
    14.     }
    15. }
    1. package Demo07;
    2.  
    3. public class demo07 {
    4.     /*
    5.     Author:代码贩子、  南京邮电大学
    6.      */
    7.     /*
    8.     除了Character以外，其余的包装类可将一个字符串作为参数构造的实例
    9.     Au
    10.      */
    11.     /*
    12.     Bollean中除了“ture”（不区分大小写）之外的其它字符串，结果都是False
    13.      */
    14.     public static void main(String[] args) {
    15.         //场景一：两个字符串进行“+”操作
    16.         String a = "123";
    17.         System.out.println(a+"1");
    18.         //场景二：一个字符串和一个基本数据类型进行“+”操作
    19.         String b = "2";
    20.         System.out.println(a+1);
    21.         //场景三：将基本数据类型转化为字符串
    22.         int c = 123;
    23.         String d = a+"1";
    24.         //场景四：两个数值类型进行“+”操作就会变成岁数操作
    25.         System.out.println(123+1);
    26.         //场景五：将字符串进行算数操作  需要使用包装类
    27.         String f = "123";
    28.         Integer f_new = new Integer(f);
    29.         System.out.println(f_new+123);
    30.         //场景六：字符与基本数据类型进行“+”操作
    31.         //Character e = new Character("男")；
    32.         Boolean g = new Boolean("dasdasd");
    33.         System.out.println(g);
    34.     }
    35. }

    2.2将包装类转化为数据类型

    intValue（）

    1. package Demo07;
    2.  
    3. public class demo07 {
    4.     /*
    5.     Author:代码贩子、  南京邮电大学
    6.      */
    7.     public static void main(String[] args) {
    8.         Integer a = new Integer(123);
    9.         int a_new = a.intValue();
    10.         Double b = new Double(3.1415926);
    11.         b.doubleValue();
    12.         Boolean c = new Boolean(true);
    13.         c.booleanValue();
    14.     }
    15. }

    toString（）基本类型转化为字符串类型

    1. package Demo07;
    2.  
    3. public class demo07 {
    4.     /*
    5.     Author:代码贩子、  南京邮电大学
    6.      */
    7.     public static void main(String[] args) {
    8.         //第一种写法
    9.         int a = 123;
    10.         String b = Integer.toString(a);
    11.         double c = 30.0;
    12.        String d = Double.toString(c);
    13.        //第二种写法（企业常用）
    14.         int e = 123;
    15.         String f = e+"";
    16.     }
    17. }

    parseXXX（）字符串类型转换为基本数据类型（Character类型除外）

    1. package Demo07;
    2.  
    3. public class demo07 {
    4.     /*
    5.     Author:代码贩子、  南京邮电大学
    6.      */
    7.     public static void main(String[] args) {
    8.         int rum = Integer.parseInt("36");
    9.         System.out.println(rum);
    10.         boolean bool1 = Boolean.parseBoolean("false");
    11.         System.out.println(bool1);
    12.     }
    13. }

    valueOf（）

    1. package Demo07;
    2.  
    3. public class demo07 {
    4.     /*
    5.     Author:代码贩子、  南京邮电大学
    6.      */
    7.     public static void main(String[] args) {
    8.         //场景一：基本类型转化为包装类
    9.         Integer intvalue= Integer.valueOf(21);
    10.         System.out.println(intvalue);
    11.         //场景二：字符串类型转化为包装类（Character除外）
    12.         Integer inteValue = Integer.valueOf("21");
    13.         double doublecalue= Double.valueOf("32");
    14.         System.out.println(doublecalue);
    15.         //报错场景
    16.         String gender = '男';
    17.         //编译报错
    18.         Character gg = Character.valueOf(gender);
    19.     }
    20. }

    2.3 装箱和拆箱

    定义：（装箱）基本类型转换为包装类型（自动转换！）

               （拆箱）包装类对象转换为基本类型的值（自动转换！）

    附注：包装类不可以取代基本数据，只有在基本数据类型需要用对象表示的时候使用。

    1. package Demo07;
    2.  
    3. public class demo07 {
    4.     /*
    5.     Author:代码贩子、  南京邮电大学
    6.      */
    7.     public static void main(String[] args) {
    8.         //基本数据类型可以转换为包装类型(装箱)  JDK1.5之后自动转化
    9.         Integer a = 5;
    10.         //包装类型也可以转换为基本数据类型（拆箱）
    11.         int b = a;
    12.     }
    13. }

    2.4 String

    package Demo07;

public class demo07 {
    /*
    Author:代码贩子、  南京邮电大学
     */
    public static void main(String[] args) {
        //存在在常量池中
        String a = "写代码";
        //存放在堆中,由变量指向堆中的代码
        String string = new String("写代码");
    }
}
  • 相关阅读:
    代码随想录day动态规划回文子串
    马尔科夫链、PCV及贝叶斯动图详解
    Java基础——了解进制和位运算
    Prometheus监控的搭建（ansible安装——超详细）
    centos7安装gitbook
    香港玉湖集团亮相进博会——展现实力风采，建立共赢平台
    科研热点|官宣！2022年JCR分区和影响因子发布时间确定！
    SPI接口原理与配置
    TikTok整合谷歌搜索功能，探索新的流量入口
    java计算机毕业设计客服管理系统源码+mysql数据库+系统+lw文档+部署
  • 原文地址：https://blog.csdn.net/weixin_45650003/article/details/126416822