【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();
	}
}
//使用内部类最大的好处是可以轻松访问外部类中的私有属性,一般很少使用。
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值