java基础知识（三）字符串和数组_java字符串数组类型

一、字符串

字符串String，由一个个字符char组成，是char类型的数组；char字符以编码存储在计算机中，因此字符串也是以很多字符编码的形式存储于计算机中，同一个字符，以不同的编码格式存储在计算机中的会不一样

字符串存储在字符串常量池中，字符串常量池就是用于存储字符串的一块内存。因为字符串需要数据进行频繁的创建与销毁，耗费时间与计算机性能。在字符串常量池中能实现数据共享，能防止重复存储相同数据，提高字符串常量池的利用率，提高计算机系统性能

Java的数据类型分为基本数据类型和引用数据类型（类、数组、接口）

数据在内存中是如何存储由数据的类型决定

二、Java中==与equals

①==：属于运算符号，可以用在引用数据类型与基本数据类型的比较，对于基本数据类型，==比较值；对于引用数据类型，==比较值的地址

例如：String a = '123';   a,b存储在字符串常量池中，共享地址，所以a==b

String b = '123';

String c = new String('123'); c和d存储在堆里面，new一次就会在堆中分配一次新空间地址，且堆中不共享数据

String d = new String('123'); 所以a≠c，c≠d

字符串的创建过程：首先会在字符串常量池中判断是否有该字符串，若有，则直接获取该字符串地址引用，若无，则分配地址空间存储字符串。栈：用来运行方法；堆：用来存储对象

②equals：属于对象的方法，用来比较两个对象的内容是否相等，通过equals()比较该类的两个对象时，等价于通过“==”比较这两个对象，使用的默认是 Object类equals()方法。由于String中的 equals方法是被重写过的，因为 Object的 equals方法是比较的对象的内存地址，而 String的 equals方法比较的是对象的值。所以当创建 String类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String对象。

注：equals方法不能用于判断基本数据类型的变量，只能用来判断两个对象是否相等。

如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址。

三、字符串拼接 +

字符串----char组成的数组，字符串大小不可变，如果要改变其大小则会重新申请一个地址不会在原地址上改变。

假设字符串大小可变，如果字符串数组地址在原有上变大，那么在内存中排在字符串后面的数组或程序都要改变地址，因为字符串数组每次是一个连续的地址空间，显然这样不可取；如果字符串地址在原有地址上变小，由于字符串数组大小是固定的，那么就意味着此时存储在此字符串中的有效数组会变小，会造成数据无效，因此字符串的大小不可变

判断字符串是否为空

String a=" "； 此时a会分配地址，指向字符常量池中的一块空的内存

String b; b不会分配地址，在栈中没有指向

因此在写判断语句时应该写成if(str==null || str.length()==0)，不能交换顺序，因此b没有指向，如果先判断长度是否为0，系统会直接报错

//字符串常用函数
String astr = "123456";
String bstr = new String("123456");    
//1、获取String的长度length()
int len = astr.length();
System.out.println(len);     //6
//2、用charAt()获取到String中指定位置的值
char a = astr.charAt(0);
System.out.println(a);        //1
//3、equals()方法判断值是否相等
System.out.println(astr.equals(bstr));      //true
//4、substring截取子串
System.out.println(astr.substring(3));      //456
System.out.println(astr.substring(3,4));    //4
 
String a = "abc";
String b = a + "dfg";
String c = a + b;   //由于字符串是不可变的字符数组，因此每一次拼接都会申请一块内存页，所以拼接速度很慢
System.out.println(c);
 
StringBuilder m1 = new StringBuilder();  //事先申请了一块很大的内存空间
m1.append("qwe");
m1.append("sdf");
System.out.println(m1.toString());//返回一个字符串
 
//StringBuilder的一些常用内置函数
int length() //返回构建器或缓冲器中的代码单元数量
 
StringBui1der append( String str) //追加一个字符串并返回this
 
StringBui1der append(char c)  //追加一个代码单元并返回 this
 
StringBui1der appendCodePoint(int cp) //追加一个代码点,并将其转换为一个或两个代码单元并返回 this 
void setCharAt ( int i, char c) //将第 i 个代码单元设置为 c
 
StringBui1der insert(int offset, String str) //在 offset 位置插入一个字符串并返回 this
StringBuilder insert(int offset, Char c)  //在 offset 位置插入一个代码单元并返回 this
 
StringBui1der delete(int startindex, int endlndex) //删除偏移量从 startindex 到endlndex - 1 的代码单元并返回 this
 
String toString()   //返回一个与构建器或缓冲器内容相同的字符串

四、String、StringBuilder、StringBuffer

StringBuilder、StringBuffer内部原理一样，StringBuilder的前身是 StringBuffer ，StringBuffer其效率稍有些低，但允许采用多线程的方式执行添加或删除字符的操作，允许多线程操作，内部加了锁更加安全；StringBuilder和StringBuffer的速度远远高于String

注：数组申请空间足够大，能够支持修改的，为缓冲区，通常带有Buffer/Builder

五、输入与输出

import java.util.*;    
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {     //判断是否还有整型输入    in.hasNext()  检测是否还有其它输入;hasNextDouble
            int a = in.nextInt();     //in.nextline   读取一行，可能包含空格    nextDouble
            int b = in.nextInt();     //in.next    读取一个字符，以空格或换行作为分隔
            System.out.println(a + b);
        }
        
        System.out.printf("输出整数：%d，输出浮点数：%f，输出字符：%s", 23, 23.32, "dsa");   //只输出不带返回值
        System.out.printf("时间：%tc====%tF=====%tT", new Date(), new Date(), new Date()); 
        String str = String.format(""时间：%tc====", new Date())      //带返回值
        System.out.println(str);
    }
}

六、switch 多重选择，可选类型：byte、char、short、int、String、枚举

int a = 'sa';
switch(a){
    case 'aa':
        //===;
        break;      //如果不加break，会一直向下全部执行，直到遇到break，这就是switch击穿
    case 'sa':
        //===;
        break;
    default:
        break;
}

七、大数值类型： Biglnteger 和 BigDecimaL，底层是字符串

使用 java . math 包中的两个很有用的类 ： Biglnteger 和 BigDecimaL 这两个类可以处理包含任意长度数字序列的数值。

Biglnteger 类实现了任意精度的整数运算 ， BigDecimal 实现了任意精度的浮点数运算，只要计算机内存够，就能无限存储计算。

import java.math.*;
BigInteger x1 = new BigInteger("1111100000000000000000000000000000000");
BigInteger x2 = new BigInteger("1111100000000000000000000000001111111");
BigInteger x_add = x1.add(x2);   //加
BigInteger x_sub = x1.subtract(x2);    //减
BigInteger x_mul = x1.mutiply(x2);     //乘
BigInteger x_div = x1.divide(x2);      //除
BigInteger x_mod = x1.mod(x2);        //求余
int d = x1.compareTo(x2);            //比较大小
//static Biglnteger valueOf (1ong x)
    //返回值等于 x 的大整数 。

八、数组（引用类型）

C语言中的数组和Java中的数组不同，Java数组是C语言指针指针类型数组，不同于C语言中的非指针类型数组

数组的每一元素都是同一类型

float[] arrf = {234.1F, 234, 'w'};   //对，float可以容纳这些类型
int[] arr = {1,2,3,4};       //arr={2,3,4,5}   这是错误的
int[] brr = new int[]{1,3,4,5,6};
brr = new int[]{2,2,34,56};   
arr = new int[3];     //==      arr={0,0,0}
 
for(int i:arr){     //for each
    System.out.println(i);    //这里的i代表的是arr中的每个元素 
}
for(int i=0;i<arr.length;i++){      //length在C语言中数组没有这个方法，但是在java,c++这些高级语言中数组都有这个方法
    System.out.println(arr[i]);    //这里的i代表的是arr的数组下标
}//这两种等价

注：基本类型的一维数组在物理地址上连续，其他数据类型在物理地址上并不连续

九、数组元素删除

public class StrPractice {
 
    public static void main(String[] args) {
 
        int[] x = {1,2,2,2,3,4};
//        for(int i=0; i<x.length; i++){
//            if(x[i]==2){
//                x = del(x,i);
//                i = i - 1;
//            }
//        }
//       如果正序删除会出现漏删，可变成逆序        
        for(int i=x.length-1; i>=0; i--) {
            if(x[i]==2){
                x = del(x,i);
            }
        }
        for(int i:x){
            System.out.println(i);
        }
        
    }
    
    public static int[] del(int[] arr, int index){
        int[] brr = new int[arr.length-1];
        for(int i=0; i<arr.length-1; i++){
            if(i>=index) {
                brr[i]=arr[i+1];
            }else {
                brr[i]=arr[i];
            }
        }
        
        return brr;
    }
 
 
}

十、数组的复制：arr = Arrays.copyOf (arr, 2 *arr.length )，主要用于数组的扩容，第一个参数为原数组，第二个为新数组的长度

十一、数组的排序：Arrays.sort(arr) 默认升序排序，底层使用的是快速排序，在原数组上进行排序，返回值为空

十二、多维数组

int[][] arr = new int[4][5];
int[][] arr = {{1,3,5,2,3},{2,4,5,6,3},{3,2,5,6,7}};
    for(int i=0; i<arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            System.out.print(arr[i][j] + " ");
        }
        System.out.println();
    }
}