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.