Java笔记_在java中,对于不再使用的内存资源,“垃圾回收器”自动将其释放。( )-优快云博客

本文链接：https://blog.youkuaiyun.com/Kcjljx/article/details/122951389

ArrayList 的底层操作机制源码分析(重点，难点.)

Vector 底层结构和源码剖析

Vector 和 ArrayList 的比较

LinkedList 底层结构

LinkedList说明

LinkedList的底层操作机制

ArrayList 和 LinkedList 比较

Hashtable 和 HashMap 对比

一、java基础

1 final关键字

基本介绍：final可以修饰类、属性、方法和局部变量

使用场景：

1) 当不希望类被继承时，使用final修饰

2) 当不希望父类的某个方法被子类覆盖/重写时，可以使用final修饰

3)当不希望类的某个属性的值被修改时，使用final修饰 public final double TAX_RATE = 0.08

4) 当不希望某个局部变量被修改时，可以使用final修饰

public void cry() { 

   //这时，NUM 也称为 局部常量 
   final double NUM = 0.01;
   //NUM = 0.9; 
   System.out.println("NUM=" + NUM); 

}

使用细节：

1)final修饰的属性又叫常量，一般用XX_XX_XX命名

2)final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下的位置之一：

①定义时：如 public final double TAX_RATE = 0.08;

②在构造器中

③在代码块中

3)如果final修饰的属性是静态的，则初始化位置只能是：

①定义时 ②在静态代码块中，但是不能在构造器中赋值

4)final类不能继承，但是可以实例化对象

5)如果类不是final类，但是含有final方法，则该方法虽然不能被重写，但是可以被继承

class Foo {
    final int i;//定义时要有初始化操作
    int j;
    public void doSomething() {
        System.out.println(++j + i);
    }
}

2 java 的动态绑定机制

1）当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

2）当调用对象属性的时候，没有动态绑定机制，哪里声明，哪里使用

3 关于JVM中的区

JVM 内存可简单分为三个区：

1、堆区（heap）：用于存放所有对象，是线程共享的（注：数组也属于对象）

2、栈区（stack）：用于存放基本数据类型的数据和对象的引用，是线程私有的（分为：虚拟机栈和本地方法栈）

3、方法区（method）：用于存放类信息、常量、静态变量、编译后的字节码等，是线程共享的（也被称为非堆，即 None-Heap）

Java 的垃圾回收器（GC）主要针对堆区

题目：

在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（错）

解析：方法调用时，会创建栈帧在栈中，调用完是程序自动出栈释放，而不是gc释放

4 java的匿名内部类

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}

class Outer04{
    private int n1 = 10;
    public void method(){
    //基于接口的匿名内部类
    IA Tiger = new IA(){
        @Override
        public void cry() {
            System.out.println("老虎在叫---");
        }
    };
            Tiger.cry();

//1.jdk底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例，并且把地址 
//返回给 tiger
//2.匿名内部类使用一次，就不能再使用
//3.使用匿名内部类来简化开发

    //基于类的匿名内部类
    Father father = new Father("tom"){
        @Override
        public void test() {
            System.out.println("匿名内部类test方法被重写");

        }
    };
    System.out.println("father 对象的运行类型=" + father.getClass());
    father.test();



    //基于抽象类的匿名对象
        Car car = new Car(){

            @Override
            void driveWhatCar() {
                System.out.println("今天开法拉利吧");
            }
        };
        car.driveWhatCar();
}
 }
interface IA {
    //接口
    public void cry();
}

class Father{//类

    public Father(String name) {
    System.out.println("接收到 name=" + name);
    }



    public void test(){

    }
}

abstract class Car{//抽象类
    abstract void driveWhatCar();
}

5 equals与"=="

"==" 是一个比较运算符，既可以判断基本数据类型，也可以判断引用类型，如果判断基本数据类型，判断值是否相等，如果判断引用类型，判断地址是否相等。

equals是Object类中的方法，只能判断引用类型。默认判断的是地址是否相等，子类往往重写改方法用于判断内容是否相等。

1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，
因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；

int a = 220;

Integer b = 220;

System.out.println(a==b);//true
2、两个Integer类型进行“==”比较， 如果其值在-128至127 ，那么返回true，否则返回false, 
这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。

Integer c=3;
Integer h=3;
Integer e=321;
Integer f=321;
System.out.println(c==h);//true
System.out.println(e==f);//false
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，
如果类型相同，则继续比较值，如果值也相同，返回true。

Integer a=1;
Integer b=2;
Integer c=3;
System.out.println(c.equals(a+b));//true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，
先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

int i=1;
int j = 2;
Integer c=3;
System.out.println(c.equals(i+j));//true

6 hashCode方法

1)  提高具有哈希结构的容器的效率！

2)  两个引用，如果指向的是同一个对象，则哈希值肯定是一样的！

3)  两个引用，如果指向的是不同对象，则哈希值是不一样的

4)  哈希值主要根据地址号来的！，不能完全将哈希值等价于地址。

5）在集合中 hashCode 如果需要的话，也会重写。

7 集合专题

集合的好处

1）可以动态保存任意对象

2）提供一系列操作对象的方法

3）使用集合添加、删除新元素简洁

2.集合的框架体系

Java 的集合类很多，主要分为两大类：(单列集合 , 双列集合)

Collection 接口有两个重要的子接口 List和Set , 他们的实现子类都是单列集合

Map 接口的实现子类是双列集合，存放的 K-V

Collection

1）接口实现类的特点

2）遍历元素方式

a.使用 Iterator(迭代器)：

step1:得到对应的迭代器

step2：快速生成 while => itit

    ps:当退出 while 循环后 , 这时 iterator 迭代器，指向最后的元素          
       iterator.next();//NoSuchElementException
       如果希望再次遍历，需要重置我们的迭代器

b.增强 for 循环

List

                                索引是从 0 开始的

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 位置的子集合
ps:注意返回的子集合 fromIndex <= subList < toIndex

List的三种遍历方式

ArrayListt 底层结构和源码分析

1.ArrayList 的注意事项

2.ArrayList 的底层操作机制源码分析(重点，难点.)

Vector 底层结构和源码剖析

扩容算法：就是扩容两倍

newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);

Vector 和 ArrayList 的比较

LinkedList 底层结构

1. LinkedList说明

1）LinkedList底层实现了双向链表和双端队列特点

2）可以添加任意元素（元素可以重复），包括null

3）线程不安全，没有实现同步

2. LinkedList的底层操作机制

linkedList.remove(); //默认删除的是第一个结点

ArrayList 和 LinkedList 比较

Set

1.基本介绍

2.常用方法

和 List 接口一样, Set 接口也是 Collection 的子接口，因此，常用方法和 Collection 接口一样

3. 遍历方式

set 接口的实现类的对象(Set 接口对象), 不能存放重复的元素, 可以添加一个 null

set 接口对象存放数据是无序(即添加的顺序和取出的顺序不一致)

注意：取出的顺序的顺序虽然不是添加的顺序，但是他的固定

HashSet

涉及判断对象/数据是否相同，可以重写HashSet里面的hashCode方法和equals方法

LinkedHashSet

基本介绍

TreeSet

TreeSet集合是按照元素的自然顺序进行排序。

Map 接口和常用方法

1.Map 接口实现类的特点

2.Map 接口常用方法

map.put(k,v);//若已经存在key，则value是替换原先的value

map.remove:根据键删除映射关系

map.get：根据键获取值

map.size:获取元素个数

map.isEmpty:判断个数是否为 0

map.clear:清除 k-v

map.containsKey:查找键是否存在

3.Map的遍历方式

方式一：先取出所有的 Key , 通过 Key 取出对应的 Value

   Set keyset = map.keySet();
//(1) 增强 for 
   System.out.println("-----增强 for-------"); 
   for (Object key : keyset) { 
   System.out.println(key + "-" + map.get(key)); 
}
//(2) 迭代器 
   System.out.println("---- 迭 代 器 --------"); 
   Iterator iterator = keyset.iterator(); 
      while (iterator.hasNext()) { 
      Object key = iterator.next(); 
   System.out.println(key + "-" + map.get(key)); 
}

方式二：把所有的 values 取出

Collection values = map.values(); 
//这里可以使用所有的 Collections 使用的遍历方法 
//(1) 增强 for 
   System.out.println("---取出所有的 value 增强 for----"); 
   for (Object value : values) { 
     System.out.println(value); 
}
//(2) 迭代器 
   System.out.println("---取出所有的 value 迭代器----"); 
   Iterator iterator2 = values.iterator(); 
   while (iterator2.hasNext()) { 
     Object value = iterator2.next(); 
     System.out.println(value); 
}

方式三：通过 EntrySet 来获取 k-v

  Set entrySet = map.entrySet();// EntrySet<Map.Entry<K,V>> 
  //(1) 增强 for
  System.out.println("----使用 EntrySet 的 for 增强(第 3 种)----"); 
  for (Object entry : entrySet) { 
  //将 entry 转成 Map.Entry 
  Map.Entry m = (Map.Entry) entry; 
  System.out.println(m.getKey() + "-" + m.getValue()); 
}
  //(2) 迭代器 
  System.out.println("----使用 EntrySet 的 迭代器(第 4 种)----"); 
  Iterator iterator3 = entrySet.iterator(); 
  while (iterator3.hasNext()) {
  Object entry = iterator3.next();
  //System.out.println(next.getClass());//HashMap$Node -实现-> Map.Entry (getKey,getValue) 
  Map.Entry Map.Entry m = (Map.Entry) entry;  //向下转型 
  System.out.println(m.getKey() + "-" + m.getValue()); } }

HashMap 小结

HashMap 底层机制及源码剖析

HashTable 的基本介绍

Hashtable 和 HashMap 对比

Map 接口实现类-Properties

开发中如何选择集合实现类(记住)

TreeSet 的底层是TreeMap

//当我们使用无参构造器，创建TreeSet时，是无序的
//使用 TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类) , 并指定排序规则


1. 构造器把传入的比较器对象，赋给了 TreeSet 的底层的 TreeMap 的属性 this.comparator 
public TreeMap(Comparator<? super K> comparator) { 
this.comparator = comparator; 
} 
2. 在 调用 treeSet.add("tom"), 在底层会执行到
     if (cpr != null) {
        //cpr 就是我们的匿名内部类(对象)
       do { parent = t; 
           //动态绑定到我们的匿名内部类(对象)
           compare cmp = cpr.compare(key, t.key);
        if (cmp < 0)      t = t.left; 
        else if (cmp > 0) t = t.right; 
        else //如果相等，即返回 0,这个 Key 就没有加入 
             return t.setValue(value);  
           }
        while (t != null); 
      }
    TreeSet treeSet = new TreeSet(); 
    TreeSet treeSet = new TreeSet(new Comparator() { 
      @Override 
      public int compare(Object o1, Object o2) {
     //下面  调用比较的方法进行比较
     //例如：调用String 的 compareTo 方法进行字符串大小比较 
     //return ((String) o2).compareTo((String) o1); 
     //如果要求加入的元素，按照长度大小排序 
     return ((String) o1).length() - ((String) o2).length(); 
     } 
});