5Java基础整理

1.API：Application programming interface

举例：System类中的 public static void arraycopy(int[] src,int srcPos,int[] dest,int[] desst,int destPos,int length)，实现数组的复制。

如果dest是null ，那么会抛出一个NullPointerException 。 如果src是null ，则抛出一个NullPointerException并且目标数组不被修改。

2.常用算法：

递归：每一级的函数调用都有自己的变量；每一次的函数的调用都会有一次返回；递归函数中，位于递归调用前的语句和各级被调用的函数具有相同的执行顺序，位于递归调用后的语句和各级被调用的函数具有相反的执行顺序。函数的代码并不会得到复制。

排序算法：

冒泡排序：一共执行n-1次，每次进行比上一轮少一次的相邻两数比较，并将最大的元素移动到n-i个位置。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr= new int[]{3,15,2,6,4,7,9,8};
        BubbleSort b = new BubbleSort();
        b.BubbleSort(arr);
        b.sysArr(arr);

    }
    public void BubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1;j++){
                if(arr[j]>arr[j+1]) swap(arr,j,j+1);
            }
        }
    }
    public void swap(int[] arr,int index1,int index2){
        int temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }
    //按照数组格式输出
    public void sysArr(int[] arr){
        String str = "[";
        for(int a:arr)
           str+=a+",";
        str = str.substring(0,str.length()-1);
        System.out.println(str+"]");
    }
}

选择排序：一共执行n-1次，每次从无序部分中选择最小值（记住下标）放在第i个位置上。

与冒泡排序的区别：冒泡排序每一轮可能会有多次交换，选择排序每一轮只有一次交换。

二分查找：基于有序的数组，每一轮将查找区间分为两部分，如果未找到，就到可能存在的区间中进行查找，直到区间中没有元素。

import java.util.Arrays;

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {12,32, 34,45, 54,65,71,82};
        BinarySearch bs= new BinarySearch();
        System.out.println( bs.binarySearch(arr,71));
        System.out.println( bs.binarySearch(arr,70));
        System.out.println(Arrays.binarySearch(arr,65));
        System.out.println(Arrays.binarySearch(arr,60));
    }
    public boolean binarySearch(int[] arr,int num){
    int left = 0,right = arr.length-1;
    while(left<=right){
        int mid = left+(right-left)/2;
        if(arr[mid]==num) {
            System.out.println(mid);
            return true;
        }
        else if(arr[mid]<num) left = mid+1;
        else right = mid-1;
    }
    return  false;
    }
}

3.Arrays工具类

常用方法：sort(int[] arr) 升序排序

fill(int[] arr,int fromIdx,int toIdx,int fillNum) 填充一定区域的数组

4.面对对象思想 Object oriented programming

面对对象开发的阶段：面对对象的分析阶段(OOA) 设计阶段（OOD） 编程(OOP)

面对对象指的是从生活中的具体事物提取特征，把现实生活中一类具有共同属性的行为的事物抽象为类，类具体化为对象。类是对象的数据类型。类是具有相同属性和行为的一组对象的集合。

5.对象的创建和引用：创建对象：类名（类型） 对象名（变量） = new 类名();

6.Java内存结构（JVM内存划分）：

JVM管理的内存区域，实际上是.class文件执行时所需要存储数据和相关信息的空间，也称为Runtime Data Area（运行时数据区）。

运行时数据区又分为方法区（虚拟机栈）、堆区、栈区、PC寄存器和本地方法栈。

程序计数器：占用内存小，线程私有，生命周期与线程相同。作用大致为字节码行号指示器。

虚拟机栈：线程私有，生命周期与线程相同，使用连续的内存空间。作用是Java方法执行时的内存模型，存储局部变量表、操作栈、动态链接、方法出口等信息。会引发StackOverflowError OutOfMemoryError异常。（栈溢出内存异常）

Java堆：线程共享，生命周期与虚拟机相同，可以不使用连续的内存地址。作用是保存对象实例，所有对象实例（包括数组）都要在堆上分配。会引发OutOfMemoryError（内存不足异常）。

方法区：线程共享，生命周期与虚拟机相同，可以不使用连续的内存地址。存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的机器代码等数据。会引发OutOfMemoryError（内存不足异常）。

运行时常量池：方法区的一部分，具有动态性。用于存储字面量以及符号引用。

每一个运行在Java虚拟机中的线程都有自己的线程栈。

程序中创建的局部变量都存放在栈上，没有默认值。创建的所有对象都在堆上。

void a(){
    String s = "abc";//s在栈上，"abc"在常量池中
}

void a(){
    String s = new String("abc");//s在栈上，对象在堆中
}

7.String类：String 是被final修饰的类，因此不能被继承。

创建String：（1）使用双引号赋值（2）借助String类包含的构造方法：String(String s)；String(char[] value)；String(char[] value, int offset, int count)；

String类在Java中是不可变的对象(immutable)，因此在使用concat()方法拼接字符串时，本质上没有拼接，而是又创建了一个新的字符串，再把新字符串赋值给原来的变量。

String中判断字符串相等：==用来判断两个字符串对象是否相等，即栈中存放的引用对象地址是否相等；equals()方法用于判断两个字符串内容是否相等。equals()判断时，首先判断是否是String类型，如果不是直接为false。

public boolean equals(Object anObject) {
    if (this == anObject) {//同一个对象 1）
        return true;
    }
    if (anObject instanceof String) {//字符串类型 2）
        String anotherString = (String) anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;//不符合1) 2)直接false
}

String创建：（1）String s = "abc";这种方式会创建1个String对象。首先会查看常量池中有没有“abc”，如果不存在，就会在常量池中直接创建"abc"，否则，直接返回”abc“的引用。因此，String s1 ="abc";String s2 = "abc"; 此时s1==s2为true。

（2）String str = new String("abc")。这种方式，会创建2个String对象。首先在常量池中创建“abc”字符串对象，然后再在堆中创建一个字符串对象，将"abc"的字符数组复制到堆中创建的对象的字符数组上。因此，String str =  new String("abc");String s = "abc"；str==s为false。new String("xxx");总是会创建一个新的堆内存对象

（3）String ss = "abc".intern();这种方式会返回一个字符串对象引用。intern()是一个本地方法。作用是查看或者创建一个常量池中的字符串引用并返回。该方法常用于将某些经常访问的字符串对象保存在常量池中，避免经常创建对象。

（4）String m = new String("123")+new String("123");首先在常量池中创建一个"123"对象，再在堆中创建"123123"对象，并返回引用。

（5）String s3 = m.intern();String s4 = "123123"; s3==s4为true。如果s3与s4反过来为false，因为上一句在堆中创建"123123"，并没有在常量池中创建，而intern()方法读取常量池，发现没有"123123"的常量，因此创建一个对象并返回引用。s4再创建时，常量池中已经有了字符串的引用。

（6）String s5 = "abc";String s6 = "abc"+"def";对于字面量的拼接，java会转化为String s5 = "abcdef";实际上只创建了一个对象。

而String s5 = "abc";String s6= s5+"def";等同于在常量池中创建"abc"和"def"两个对象，在堆中创建"abcdef"这个对象。它的实现过程等同于

String s5 = "abc";String s6 = new StringBuilder().append(s5).append("def").toString();

8.String常用方法

public char charAt(int index)
public int length()
public int indexOf(String str)
public int indexOf(String str,int fromIndex)从fromIdx开始搜索子串的位置
public boolean equalsIgnoreCase(String another)
public String replace(char oldChar,char newChar)
public boolean startsWith(String prefix)
public boolean endsWith(String suffix)
public String toUpperCase()
public String toLowerCase()
public String substring(int beginIndex)
public String substring(int beginIndex,int endIndex)
public String trim()

public static String valueOf(基本数据类型参数)

public String[] split(String regex) 要注意split方法中实际使用regex，所以.的分割要使用\\.

9.StringBuffer：线程安全 StringBuilder：非线程安全（快）

StringBuffer()：构造一个空白的字符串缓冲区，其初始容量为 16 个字符。（底层是长度为16的字符数组）

StringBuffer(String str)：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

StringBuffer主要方法：

public StringBuffer append(String str)
public StringBuffer append(StringBuffer str)
public StringBuffer append(char[] str)
public StringBuffer append(char[] str,int offset,int len)
public StringBuffer append(double d)
public StringBuffer append(Object obj)
public StringBuffer insert(int offset,String str)

StringBuffer是一个内容可变的字符序列。

      

10.java.util.Date类

Date(long millisec)
long getTime()
boolean after(Date date)
boolean before(Date date)

API 　　　　　　　　   含义
Instant 　　　　　         时间戳
LocalDate 　　　　　　日期，如 2020-06-16
LocalTime　　　　　　 时刻，如 11:52:52
LocalDateTime 　　　   具体时间，如 2020-06-16 11:52:52

java.util包还提供了SimpleDateFormat、Calendar和Math类等常用类。

11.很多连在一起的分隔符的split()情况

 String s1 = ",,,,,,k,x,,,x,x,,,,,,,,,";
        for(String s:s1.split(","))
            System.out.println(s.length());

String s1 = ",,,,,,k,x,,,x,x,,,,,,,,,";
　　　　　for(String s:s1.split(","))
   　　　　 System.out.println(s.equals(""));

String s1 = ",,,,,,k,x,,,x,x,,,,,,,,,";
　　　for(String s:s1.split(","))
　　　　System.out.println(s=="");

输出结果为：

0 　　true 　　false
0 　　true 　　false
0 　　true 　　false
0 　　true 　　false
0 　　true 　　false
0 　　true 　　false
1　　false 　　false
1　　false 　　false
0 　　true 　　false
0 　　true 　　false
1　　false 　　false
1　　false 　　false

由此可以看出，当分隔符在其他文本的前面时，这个分隔符就会分出长度为空的对象“”，但是如果在所有的其他字符后面，就不会再分。

　　　　 String s1 = new String("");
        String s2 = new String("");
        String s3 = "";
        String s4 = "";
        System.out.println(s1==s2);
        System.out.println(s3==s4);

由此可以看出，split()方法返回的字符串是在堆中new出来的字符串对象。

12.System.out.println(res.substring(0,res.length()));最后一个参数可以是取不到的res.length()位置

scanner.next(）遇到空白就结束 scanner.nextLine()读取一整行

13.字符串拼接

每次对String进行拼接操作，实际在jvm中都是new了一个新的String，随着String的new的次数越多，会造成虚拟机速度下降。

效率：StringBuilder>StringBuffer(非线程安全快于线程安全)>String.concat>String+  ==  String+=

String类本身是final类型，字符串拼接时，会使用StringBuffer，并调用append，之后再调用toString方法。
　　而StringBuffer转换成String时，开销相当大。中间不仅创立了临时对象StringBuffer，还每次完后再要转成String。

14.