JavaSE-基础篇学习笔记分享（四）

自学玩家
237 阅读19分钟

笔记整理自B站尚硅谷JavaSE视频，其中可能有记录内容不正确，望诸位指出

作者：Vison

25、注解

  • 定义新的Annotation 类型使用 @interface 关键字
  • 自定义注解自动继承了java.lang.annotation.Annotation接口
  • Annotation 的成员变量在 Annotation 定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型。 我们称为配置参数。类型只能是八种基本数据类型、String类型、Class类型、enum类型、Annotation类型、以上所有类型的数组。
  • 可以在定义 Annotation 的成员变量时为其指定初始值，指定成员变量的初始值可使用 default 关键字
  • 如果只有一个参数成员，建议使用参数名为value
  • 如果定义的注解含有配置参数，那么使用时必须指定参数值，除非它有默认值。格式是“参数名 =参数值”，如果只有一个参数成员，且名称为value，可以省略“value=”
  • 没有成员定义的 Annotation 称为标记:包含成员变量的Annotation称为元数据Annotation

注意:自定义注解必须配上注解的信息处理流程才有意义。

@author标明开发该类模块的作者，多个作者之间使用，分割

@version 标明该类模块的版本

@see参考转向，也就是相关主题

@since 从哪个版本开始增加的

@param 对方法中某参数的说明，如果没有参数就不能写

@return 对方法返回值的说明，如果方法的返回值类型是void就不能写

@exception 对方法可能抛出的异常进行说明，如果方法没有用throws显式抛出的异常就不能写 其中：

@param @return 和@exception 这三个标记都是只用于方法的。

@param的格式要求:

@param 形参名 形参类型形参说明
@return 的格式要求:
@return 返回值类型 返回值说明
@exception的格式要求:
@exception 异常类型 异常说明
@param和@exception可以并列多个

@Override: 限定重写父类方法,该注解只能用于方法

@Deprecated: 用于表示所修饰的元素(类,方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择

@SuppressWarnings: 抑制编译器警告

26、枚举

枚举的使用

枚举类的实现

JDK1.5之前需要自定义枚举类
JDK1.5新增的 enum 关键字用于定义枚举类

若枚举只有一个对象，则可以作为一种单例模式的实现方式。

枚举类的属性

枚举类对象的属性不应允许被改动，所以应该使用 private final修饰>枚举类的使用 private final 修饰的属性应该在构造器中为其赋值
若枚举类显式的定义了带参数的构造器，则在列出枚举值时也必须对应的传入参数

1.私有化类的构造器，保证不能在类的外部创建其对象
2.在类的内部创建枚举类的实例。声明为:public static final
3.对象如果有实例变量，应该声明为private final，并在构造器中初始化

class season{
    private final string SEASONNAME;//季节的名称 
    private final string SEASONDESC;//季节的描述
    private Season(String seasonName,String seasonDesc){
        this.SEASONNAME = seasonName;
        this.SEASONDESC = seasonDesc;
    }
    public static final Season SPRING = new Season("春天"，"春暖花开"); 
    public static final Season SUMMER = new Season("夏天"，"夏日炎炎"); 
    public static final Season AUTUMN = new Season("秋天"，"秋高气爽"); 
    public static final Season WINTER = new Season("冬天"，"白雪皑皑");
}

使用说明

使用enum 定义的枚举类默认继承了java.lang.Enum类，因此不能再继承其他类
枚举类的构造器只能使用private权限修饰符
枚举类的所有实例必须在枚举类中显式列出(，分隔 ;结尾)。列出的实例系统会自动添加public static final 修饰
必须在枚举类的第一行声明枚举类对象 JDK 1.5 中可以在 switch 表达式中使用Enum定义的枚举类的对象作为表达式.case 子句可以直接使用枚举值的名字,无需添加枚举类作为限定。

public enum SeasonEnum {
    SPRING("春天"，"春风又绿江南岸"), 
    SUMMER("夏天"，"映日荷花别样红"), 
    AUTUMN("秋天"，"秋水共长天一色"), 
    WINTER("冬天"，"窗含西岭千秋雪");
    private final String seasonName; 
    private final string seasonDesc;
    private SeasonEnum(String seasonName, String seasonDesc){
        this.seasonName = seasonName; 
        this.seasonDesc = seasonDesc;
    }
    public string getseasonName(){
        return seasonName;
    }
    public string getseasonDesc() {
        return seasondesc;
    }
}

枚举的方法

方法名详细描述
valueOf传递枚举类型的Class对象和枚举常量名称给静态方法valueOf，会得到与参数匹配的枚举常量。
toString得到当前枚举常量的名称。你可以通过重写这个方法来使得到的结果更 易读。
equals在枚举类型中可以直接使用"=="来比较两个枚举常量是否相等。Enum 提供的这个equals()方法，也是直接使用"=="实现的。它的存在是为了在Set,List和Map中使用。注意，equals()是不可变的。
hashCodeEnum实现了hashCode()来和equals保持一致。它也是不可变的。
getDeclaringClass得到枚举常量所属枚举类型的Class对象。可以用它来判断两个枚举常量是否属于同一个枚举类型。
name得到当前枚举常量的名称。建议优先使用toString。
ordinal得到当前枚举常量的次序。
compareTo枚举类型实现了Comparable接口，这样可以比较两个枚举常量的大小(按照声明的顺序排列)
clone枚举类型不能被Clone。为了防止子类实现克隆方法，Enum实现了一个仅抛出CloneNotSupportedException异常的不变Clone

Enum类的主要方法:

values()方法:返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。

valueOf(String str):可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常: lllegalArqumentException

toString():返回当前枚举类对象常量的名称

27、集合

image.png

    hasNext():判断是否还有下一个元素

    while(iterator.hasNext()){

        //next():①指针下移 ②将下移后的集合位置上的元素返回

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

}

集合元素的遍历操作，使用迭代器Iterator接口

内部的方法：hasNext()和next();

集合对象每次调用iterator()方法都得到一个全新的迭代器对象

默认的游标都在集合的第一个元素之前

hasNext()判断是否还有下一个元素

集合的分类

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

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

数组再存储多个数据方面的特点：

一旦初始化以后，其长度就确定了

数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了

比如：String[] arr; int[] arr1; Object[] arr2;

数组再储存多个数据方面的缺点：

一旦初始化以后，长度就不可修改了

数组中提供的方法非常有限，对于添加，删除，插入数据等操作，非常不便，同时效率不高

获取数组中实际元素的个数的需求，数组没有线程的属性或方法

数组储存数据的特点：有序，可重复，对于无序，不可重复的需求，不能满足

集合框架

  • Collection接口：单例集合，用来储存一个一个的对象

    • List接口：存储有序的，可重复的数据

      • ArrayList   LinkedList   Vector

    • set接口：存储无序的，不可重复的数据

      • HashSet   LinkedHashSet   TreeSet

    • Map接口：双列集合，用来储存一对（key - value）一对的数据

      • HashMap   LinkedHashMap   TreeMap   Hashtable   Properties

image.png

image.png

Map

Map中定义的方法

  • 添加、删除、修改操作：
  • Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
  • void putAll(Map m):将m中的所有key-value对存放到当前map中
  • Object remove(Object key)：移除指定key的key-value对，并返回value
  • void clear()：清空当前map中的所有数据
  • 元素查询的操作：
  • Object get(Object key)：获取指定key对应的value
  • boolean containsKey(Object key)：是否包含指定的key
  • boolean containsValue(Object value)：是否包含指定的value
  • int size()：返回map中key-value对的个数
  • boolean isEmpty()：判断当前map是否为空
  • boolean equals(Object obj)：判断当前map和参数对象obj是否相等
  • 元素操作的方法：
  • Set keySet()：返回所有key构成的Set集合
  • Collection values()：返回所有value构成的Collection集合
  • Set entrySet()：返回所有key-value对构成的Set集合

总结：常用方法

  •  添加：put(Object key,Object value)

  •  删除：remove(Object key)

  •  修改：put(Object key,Object value)

  •  查询：get(Object key)

  •  长度:size()

  •  遍历：keySet() / values() / entrySet()

Map的实现类的结构

  • Map:双列数据，存储key-value对的数据

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

    • LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历

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

    • Hashtable：作为古老的实现类：线程安全的，效率低：不能储存null和key和value

    • Properties：常用来处理配置文件

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

HashMap

HashMap是Map接口使用频率最高的实现类

允许使用null键和null的值，与HashSet一样，不保证映射顺序

所有的key构成的集合是Set：无序的，不可重复的，所以，key所在的类要重写equals()和hashCode()

所有的value构成的集合是Collection：无序的，可以重复的，所以，value所在的类要重写equals()

一个key-value构成一个entry

所有的entry构成的集合是Set：无序的，不可重复的

HashMap判断两个key相等的标准是：两个key通过equals()方法返回true,hashCode的值也相等.

HashMap判断两个value相等的标准是：两个value通过equals()方法返回true.

LinkedHashMap

LinkedHashMap是HashMap的子类

在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序

与LinkedHashSet类似，LinkedHashMap可以维护Map的迭代顺序：迭代顺序与Key-Value对的插入顺序一致

HashMap中的内部类：Node
static class Node<K,V> implements Map.Entry<K,V>{
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
}

LinkedHashMap中的内部类：Entry
static classs Entry<K,V> extends HashMap.Node<K,V>{
    Entry<K,V> before,after;
    Entry(int hash,K key,V value, Node<K,V>next){
        super(hash,key,value,next);
    }
}
TreeMap

TreeMap存储 Kev-Value 对时，需要根据 kev-value 对进行排序。
TreeMap可以保证所有的 Key-Value 对处于有序状态。 TreeSet底层使用红黑树结构存储数据
TreeMap的 Key的排序:

自然排序:TreeMap 的所有的 Key必须实现 Comparable接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException

定制排序:创建 TreeMap 时，传入一个Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map的 Key实现 Comparable接口 TreeMap判断两个key相等的标准:两个key通过compareTo()方法或者compare()方法返回0。

HashTable

（1）Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。

（2）Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。

（3）Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。

Hashtable和HashMap到底有哪些不同呢:

（1）基类不同：HashTable基于Dictionary类，而HashMap是基于AbstractMap。
Dictionary是什么？
它是任何可将键映射到相应值的类的抽象父类，而AbstractMap是基于Map接口的骨干实现，它以最大限度地减少实现此接口所需的工作。

（2）null不同：HashMap可以允许存在一个为null的key和任意个为null的value，但是HashTable中的key和value都不允许为null。

（3）线程安全：HashMap时单线程安全的，Hashtable是多线程安全的。

（4）遍历不同：HashMap仅支持Iterator的遍历方式，Hashtable支持Iterator和Enumeration两种遍历方式。

Properties

Properties 类是 Hashtable的子类，该对象用于处理属性文件
由于属性文件里的 key、value 都是字符串类型，所以 Properties里的 key和 value 都是字符串类型 存取数据时，建议使用
setProperty(String keyString value)方法和 getProperty(String key)方法

Properties pros =new Properties();
pros.load(new FileInputStream("jdbc.properties")); 
String user = pros.getProperty("user"); 
System.out.println(user);

HashMap的底层：

jdk 7 及之前 ---> 数组 + 链表

jdk 8 --> 数组 + 链表 + 红黑树

面试题：
1.HashMap的底层实现原理
2.HashMap和Hashtable的异同
3.CurrentHashMap 与 Hashtable 的异同

Map的结构理解

Map中的key：无序的，不可重复的，使用Set存储所有的key --->key所在的类要重写equals()和hashCode()

Map中的value:无序的，可重复的，使用Collection存储所有的value --->value所在的类要重写equals,一个健值对：Key-value构成一个Entry对象

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

HashMap的底层实现原理

HashMap map = new HashMap();
在实例化以后，底层创建了长度时16的一维数组Entry[] table.
map.put(key1,value1):

首先，调用key1所在类的hashCode()计算key1哈希值

此哈希值经过某种算法以后，得到Entry数组中得存放位置

如果此位置上得数据为空，此时得key1-value1添加成功
如果此位置上得数据不为空，意味着此位置上存在一个或多个数据(以链表得形式存在)，

比较key1和已经存在得一个或多个数据的哈希值：

如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功
如果key1的哈希值和已经存在的数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法

如果equals()返回false:此时key1-value1添加成功
如果equals()返回true：使用value1替换value2.

补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储

在不断的添加过程中，会涉及到扩容问题，默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。

jdk8相较于jdk7的底层实现方面的不同：

1.new HashMap();底层没有创建一个个长度为16的数组
2.jdk8底层的数组时：Node[]，而非Entry[]
3.首次调用put()方法时，底层创建长度为16的数组
4.jdk7底层结构只有：数组 + 链表 jdk8中底层结构：数组 + 链表 + 红黑树

当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64， 此时此索引位置上的所有数据改为红黑树存储

Collection

Conllection常用方法

1、添加

add(Object obj) addAll(Collection coll) 2、获取有效元素的个数 int size() 3、清空集合 void clear() 4、是否是空集合 boolean isEmpty() 5、是否包含某个元素 boolean contains(Object obi):
是通过元素的equals方法来判断是否是同一个对象

boolean containsAll(Collectionc):
也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。

6、删除

boolean remove(Object obi)
通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素

boolean removeAll(Collection coll)
取当前集合的差集

7、取两个集合的交集

boolean retainAll(Collection c)
把交集的结果存在当前集合中，不影响c

8、集合是否相等

boolean equals(Object obj)

9、转成对象数组

Object[] toArray()

10、获取集合对象的哈希值

hashCode()

11、遍历

iterator():返回迭代器对象，用于集合遍历

List

  • Collection接口：单例集合，用来储存一个一个的对象

    • List接口：存储有序的，可重复的数据：--->“动态”数组,替换原有的数组

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

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

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

  • ArrayList源码分析

    • jdk 7 情况下

      • ArrayList list = new ArrayList();底层创建了长度为10的Object[]数组elementDate

      • list.add(123);//elementDate[0] = new Integer(123);

      • ...

      • list.add(11);如果此次的添加导致底层elementDate数组容量不够，则扩容

      • 默认情况下，扩容原来的容量为1.5倍，同时需要将原有数组中的数据赋值到新的数组中

    结论：建议开发中使用带参的构造器ArrayList list = new ArrayList(int capacity)

    • jdk 8 情况下

      • ArrayList list = new ArrayList(); //底层Object[] elementData初始化为{}，并没有创建长度10的数组
      • List.add(123); 第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementDate[0]
      • ...
      • 后续的添加和扩容操作与jdk 7 无异

    • 小结 jdk7中的ArrayList的对象的创建类似于单例的饿汉式，
      jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

  • LinkedList的源码的分析

    • LinkedList list = new LinkedList();

    • 内部声明了Node类型的first和last属性，默认值为null

    • List.add(123);

    • 将123封装到Node中，创建了Node对象。

    • 其中，Node定义体现了LinkedList的双向链表的说法

面试题：ArrayList，LinkedList，Vector三者的异同

同：三个类都实现了List接口，存储数据的特点相同：存储是有序的，可重复的数据

不同：见上

常用方法

  • void add(int index, Object ele):在index位置插入ele元素
  • boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
  • Object get(int index):获取指定index位置的元素
  • int indexOf(Object obj):返回obj在集合中首次出现的位置
  • int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
  • Object remove(int index):移除指定index位置的元素，并返回此元素
  • Object set(int index, Object ele):设置指定index位置的元素为ele
  • List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

总结：常用方法
增：add(Object obj)
删: remove(int index)/remove(Object obj)
改: set(int index,Object ele)
查: get(int index)
插: add(int index, Object ele)
长度: size()
遍历 ①Iterator 迭代器方式 ②增强for循环 ③普通的循环

ArrayList

ArrayList是List接口的典型实现类，主要实现类
本质上，ArrayList是对象引用的一个“变长数组”

LinkedList

对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高

Vector

是一个古老的几个，大多数操作与ArrayList相同，区别在于Vector是线程安全的

Set

Set：存储无序的，不可重复的数据

HashSet

1.无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的
2.不可重复性：保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个

添加元素的过程：以HashSet为例：

我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值。

此哈希值接着通过某种算法计算处HashSet底层数组中的存放位置(即为：索引位置)，

判断数组此位置上是否已经有元素：

如果此位置上没有其他元素，则元素a添加成功--->情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素)，则比较元素a与元素b的hash值：

如果hash值不相同，则元素a添加成功。---->情况2
如果hash值相同，进而需要调用元素a所在类的equals()方法：

equals()返回true，元素a添加失败
equals()返回false，则元素a添加成功---->情况3

对于添加成功的情况2和情况3而言：元素a与已经存在指定索引位置上数据以链表的方式储存。
jdk7： 元素a放到数组中，指向原来的元素
jdk8： 原来的元素在数组中，指向元素a
总结：7上8下

HashSet底层：数组+链表的结构

LinkedHashSet

LinkedHashSet是HashSet的子类

LinkedHashSet根据元素的 hashCode值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。

LinkedHashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素时有很好的性能。

LinkedHashSet不允许集合元素重复。

TreeSet

1.向TreeSet中添加的数据，要求是相同类的对象。
2.两种排序方式：自然排序(实现comparable接口) 和 定制排序(实现compare)
3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再时equals();
4.定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals();

  • 排序操作：（均为static方法）
    • reverse(List)：反转 List 中元素的顺序
    • shuffle(List)：对 List 集合元素进行随机排序
    • sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
    • sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
    • swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
  • 查找、替换
    • Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
    • Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
    • Object min(Collection)
    • Object min(Collection，Comparator)
    • int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
    • void copy(List dest,List src)：将src中的内容复制到dest中
    • boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的所有旧值
avatar
文章
阅读
粉丝