【Java学习3】数组和String类

数组概念

数组可以将多个变量进行统一的命名，这样相同类型的元素按照一定的顺序排序。在JAVA中，数组属于引用数据类型，所以在数组的操作中，也会涉及到内存的分配问题。

声名并开辟数组

/*
数据类型 数组名称 [] = new 数据类型 [长度]
数据类型 数组名称 [] = new 数据类型 []{值1，值2....}
*/
public class Text{
    public static void main(String args[]){
        int arrayInt [] = new int [3]; //动态初始化，先开辟数组空间，再为数组中的内容赋值
        arrayInt[0] = 1;
        arrayInt[1] = 2;
        arrayInt[2] = 3;

        int int1 [] = new int [] {1,2,3,4}; //静态初始化
        for (int i = 0; i < arrayInt.length; i++){
            System.out.println(i);
        }
    }
}

二维数组

public class Text{
    public static void main(String args[]){
        int int1 [][] = new int [] [] {
            {1,2},{3,4},{5,6}
        };
        for (int i = 0; i < int1.length; i++){
            for(int j = 0; j < int1[i].length; j++){
                System.out.print(int1[i][j] + "\t");
            }
        }
    }
}

数组与方法参数的传递

数组也是引用数据类型，那么也可以通过方法进行参数传递及返回。

public class Text{
    public static void main(String args[]){
        int i1 [] = new int []{1,2,3};
        int i2 [] = add(i1);
        for(int i = 0; i < i2.length; i++){
            System.out.println(i2[i]);
        }
    }
    public static int [] add(int int1[]){
        for(int i = 0; i < int1.length; i++){
            int1[i] = int1[i] * 2;
        }
        return int1;
    }
}

数组常用方法

数组复制

数组复制可以将一个数组的部分内容复制到另一个数组之中。

/*
System.arraycopy(源数组名称,源数组复制开始索引,目标数组名称,目标数组复制开始索引,长度);
*/
public class Text{
    public static void main(String args[]){
        int i1 [] = new int []{1,2,3};
        int i2 [] = new int []{4,5,6};
        System.arraycopy(i1,1,i2,0,2);
        for(int i = 0; i < i2.length; i++){
            System.out.println(i2[i]); // 2,3,6
        }
    }
    
}

数组排序

此方法排序只适合基本数据类型

/*
java.util.Arrays.sort(数组名称);
java.util是一个java的系统包名称，Arrays是一个系统提供的类
*/
public class Text{
    public static void main(String args[]){
        int i1 [] = new int []{1,3,2,7,6,9,0};
        java.util.Arrays.sort(i1);
        for(int i = 0; i < i1.length; i++){
            System.out.println(i1[i]); // 2,3,6
        }
    }
}

对象数组

数组不仅可以保存基本数据类型，也可以保存引用数据类型，也就是说数组可以保存String、对象等引用数据数据类型。
对象数据的最大好处是将多个对象统一进行管理

/*
类名称 对象数组名称 [] = new 类名称 [长度]
类名称 对象数组名称 [] = new 类名称 [] {实例化对象,实例化对象,......}
*/
class Book{
    private String title;
    private Double price;
    /*
    setter和getter省略
     */
    public Book(){}
    public Book(String s, Double b){
        title = s;
        price = b;
    }
    public String getInfo(){
        return "title:" + title + "\t price:" + price;
    }
}
public class Text{
    public static void main(String args[]){
        Book b1 [] = new Book []{
            new Book("JAVA",54.2),
            new Book("PHP",34.2),
            new Book("PYTHON",46.8)
        };
        for (int i = 0; i < b1.length; i++){
            System.out.println(b1[i].getInfo());
        }
    }
    /*
    title:JAVA	 price:54.2
    title:PHP	 price:34.2
    title:PYTHON	 price:46.8
    */
}

String类匿名对象

任何编程语言都没有提供字符串数据类型的概念，同样在JAVA里也是通过使用char数组来保存字符串的定义。
String是用来定义字符串类型，它不属于基本数据类型，是一个特殊的引用数据类型。

String s1 = "你好"; //String类的匿名对象
String str = new String("hello");  //利用构造方法进行实例化

那么这两种实例化有什么区别呢？
String匿名对象的数据保存在JVM底层的一个对象池，当有新的String匿名对象设置了同样的内容后，将不会开辟新的内存空间，而是使用已有的对象进行引用分配，也就说是共享的。
而利用new关键字会开辟一个新的内存空间保存该值，不管该值是否相同，都将会开辟新内存空间进行保存。
所以使用String匿名对象可以节约内存空间

String类常用方法

• String.charAt()：返回char指定索引处的值

String s1 = "hello";
System.out.print(s1.charAt(1)); //e

• String.leng()：返回字符串长度
• String.isEmpty()：判断字符串是否为空或0
• String.getBytes()：将字符串转换为字节数组

String s1 = "hello";
byte b1 [] = s1.getBytes();
for (byte b : b1) {
     System.out.print(b + "\t");//104	101	108	108	111
}

• String.equals()：字符串比较
• String.startsWith()：是否以指定字符串开头
• String.startsWith()：是否以指定字符串结尾
• String.indexOf()：返回指定字符串第一次出现的索引
• String.lastIndexOf()：返回指定字符串最后一次出现的索引
• String.substring()：不用多说了吧，sql注入中常用到
• String.concat()：连接字符串，相当于s1+s2
• String.replace()：替换字符串
• String.replaceAll()：替换满足条件的所有字符串
• String.split()：分割字符串
• String.join()：以指定符号连接字符串
• String.trim()：删除首尾空格
• String.toCharArray()：转换为字符数组

更多详情请查看JDK文档

this关键字

this可以完成三件事：调用本类属性、调用本类方法、表示当前对象。

调用本类属性

class Book{
    private String title;
    private Double price;
    /*
    setter和getter省略
     */
    public Book(){}
    public Book(String title, Double price){
        this.title = title; //this.属性名，调用本类属性
        this.price = price;
    }
    public String getInfo(){
        return "title:" + this.title + "\t price:" + this.price;
    }
}

调用本类方法

• 调用本类普通方法：this.方法()
• 调用本类构造方法：this()

class Book{
    private String title;
    private Double price;
    /*
    setter和getter省略
     */
    public Book(){}
    public Book(String title){
        this();
        this.title = title;
    }
    public Book(String title, Double price){
        this(title);
        this.price = price;
    }
    public String getInfo(){
        return "title:" + this.title + "\t price:" + this.price;
    }
}

注意！使用this()调用构造方法时只能放在构造方法的首行
进行构造方法互相调用时，一定要保留出口

表示当前对象

class Book{
    public void print(){
        System.out.print(this + "\n");
    }
}
public class Text{
    public static void main(String args[]){
        new Book().print();//Book@15615099
        new Book().print();//Book@1edf1c96
    }
}

static关键字

使用static定义属性和方法，那么该属性和方法就是公共的

定义属性

//使用static修饰属性后，这个属性将成为公共属性，任何一个对象修改了此属性的内容都会影响其它对象。
class Book{
    static String title;//使用static修饰属性
    public void getinfo(){
        System.out.print(this.title);
    }
}
public class Text{
    public static void main(String args[]){
        Book.title = "JAVA";//则不需要实例化就可修改
        new Book().getinfo(); //JAVA
    }
}

JAVA内存空间

• 栈内存：保存所有对象引用的堆内存空间地址
• 堆内存：保存每个对象的具体属性内容
• 全局数据区：保存static类型的属性
• 全局代码区：保存所有方法定义

所以定义方法也是同样的道理，可以不实例化直接通过：类名称.方法进行调用

代码块

普通代码块

把一个代码块写到方法里，就是普通代码块。主要用于变量名重名问题。

public class Text{
    public static void main(String args[]){
       {
        int num = 2;  //局部变量
       }
       int num = 10; //全局变量
    }
}

构造块

将一个代码块写到一个类中，就是构造块。构造块在每一次实例化对象时都会被调用，且优先于构造方法执行。

class Book{
	public Book(){};
	{
	System.out.print("类中的构造块");
		//构造块
	}
}

静态块

如果一个代码块用static定义，就是静态块。在类中定义，那么当有多个实例化对象时，静态块会优先调用，且只调用一次，主要作用是为static属性做初始化。
如果在主类中使用，则优先于主方法main()执行。

内部类

是指在一个类的内部继续定义其它内部结构类

class Book{
	private String title = "JAVA";
	class Book1{
		public void print(){
			System.out.print(title);
		}
	}
	public void fun(){
		new Book1().print();
	}
}
//使用内部类最大的好处是可以轻松访问外部类中的私有属性，一般很少使用。