Java 基础知识点笔记总结

Posted 2021-12-22 IT_Holmes

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java 基础知识点笔记总结相关的知识，希望对你有一定的参考价值。

文章目录

1. 数组与集合概述
2. Collection 接口和 Map接口集合
3. Collection接口集合
- 3.1 Collection 接口方法
- 3.2 集合转数组和数组转集合的一些方法
4. Iterator 遍历
- 4.1 使用 Iterator 遍历Collection
- 4.2 使用foreach循环遍历集合元素
5. Collection 子接口之一 list接口
6. Collection 子接口之二 set接口
7. Map接口
8. Collections 工具类
- 8.1 常用的工具类
- 8.2 Collections常用方法同步控制

1. 数组与集合概述

集合，数组都是对多个数据进行存储操作的结构，简称Java容器。

注意的是：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(.txt , .jpg , .avi , 数据库中)。

数组存储的特点：

一旦初始化以后，其长度也就确定了。
一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
例如：String[] arr , int[] arr1 , Object[] arr2。

数组的弊端：

集合存储的优点：

解决数组存储数据方面的弊端。

2. Collection 接口和 Map接口集合

Collection接口是单例集合，用来存储一个一个的对象。
它有两个子接口：List接口和Set接口。

Collection接口继承树：

Map接口是双列集合，用来存储一对(key - value)一对的数据。

下面是Map接口的继承树：

3. Collection接口集合

3.1 Collection 接口方法

package com.holmes.java07;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;

public class CollectionTest2 
    @Test
    public void test()
        Collection coll = new ArrayList();

        //1. add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());

        //2. size():获取添加的元素的个数
        System.out.println(coll.size());

        //addAll(Collection collName):将collName集合中的元素全部添加到当前的集合中。
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);
        System.out.println(coll);

        //3. isEmpty():判断当前集合是否为空(不是判断是null，是判断集合中是否有元素)
        System.out.println(coll.isEmpty());//false

        Collection coll2 = new ArrayList();
        coll2.add(null);
        System.out.println(coll2.isEmpty());//false

        //4. clear():清空集合元素
        coll.clear();
        System.out.println(coll.isEmpty());

注意事项：

add()方法只能填对象。
向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()方法(不然像contain()进行比较时，比较的就是地址，而不是值)。

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 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(p);

        //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(p));//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<String> 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关于JAVA 反射 基础知识/编码经验的一些总结
 关于JAVA 异常 基础知识/编码经验的一些总结
 关于JAVA 反射 基础知识/编码经验的一些总结
 关于JAVA 异常 基础知识/编码经验的一些总结
 Java 基础知识点 笔记总结
 Java 基础知识点 笔记总结

Java 基础知识点 笔记总结

文章目录

1. 数组 与 集合 概述

2. Collection 接口 和 Map接口 集合

3. Collection接口 集合