Java数组及常用类

一、 数组

1. 数组简介

  • 数组是一组数据的集合
  • 数组作为一种引用类型,申请的空间在堆中
  • 数组元素的类型可以是基本类型,也可以是引用类型,但同一个数组只能是同一种类型
  • 数组作为对象,数组中的元素作为对象的属性,除此之外数组还包括一个成员属性 length, length 表示数组的长度
  • 数组的长度在数组对象创建后就确定了,就无法再修改了
  • 数组元素是有下标的,下标从 0 开始,也就是第一个元素的下标为 0,依次类推最后一个元素的下标为n-1,我们可以通过数组的下标来访问数组的元素

2. 如何在数组中存放多个数据类型?

可以利用多态的思维,将数组定义成父类,则数组中可以存放子类,当然最大的父类是Object!!!!

public class Test {
    public static void main(String[] args){
       Object [] a = new Object[5];
       a[0] = 1;
       a[1] = 1.1;
       a[2] = true;
       a[3] = "123";
       a[4] = '1';
       System.out.println(Arrays.toString(a));//[1, 1.1, true, 123, 1]
    }
}

3. 数组的初始化方式有几种?

  • 使用 new 操作符来创建数组,再初始化 ,type[] 变量名 = new type[数组中元素的个数]
  • 通过大括号的方式直接初始化,type[] 变量名 = new type[]{逗号分隔的初始化值};

4. 数组如何比较?

数组内容的比较可以使用 equals()方法吗?

public class ArrayTest06
{
    public static void main(String[] args)
    {
        int[] a = {1, 2, 3};
        int[] b = {1, 2, 3};
        System.out.println(a.equals(b));//false
    }
}

数组是引用类型,使用equals()方法调用的是Object的equals()方法,执行的依然是==,也就是地址比较。

解决方案

  • 自己写工具类,先判断是否为空,再判断长度是否相同,最后顺序比较内容
public class ArrayEqualsTest07
{
    public static boolean isEquals(int[] a, int[] b)
    {
        if( a == null || b == null )
        {
            return false;
        }
        if(a.length != b.length)
        {
            return false;
        }
        for(int i = 0; i < a.length; ++i )
        {
            if(a[i] != b[i])
            {
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args)
    {
        int[] a = {1, 2, 3};
        int[] b = {1, 2, 3};
        System.out.println(isEquals(a,b));
        System.out.println(Arrays.equals(a,b));
    }
}
  • 利用Arrays.equals()方法比较

5. 数组的扩容及优化

1、数组长度不可变,那么数组怎么扩容呢?

  • 原数组满了之后,可以新建一个新的容量更大的数组,将原数组中的数据拷贝到新数组中,原数组对象被 GC 回收,以后向新数组中存储数据。这就是数组的扩容。

2、数组扩容涉及到数组的拷贝,数组拷贝会耗费大量的资源。

3、数组怎么优化,怎么样可以提高效率?

  • 创建数组的时候,预先估计数组中存储的元素个数,给定初始化容量,减少数组的扩容次数,减少数组的拷贝,提高程序的执行效率

6. 数组的拷贝

public class ArrayTest08
{
    public static void main(String[] args){
        int[] src = {5,6,9,8,2,3,6,7,5,6,4,2,3,8,9};
        int[] dest = {1,1,1,1,1,1,1,1,1};
        //这里调用的是自己写的 arraycopy
        //arraycopy(src,3,dest,1,4);
        //调用 JDK 库中 System 类中提供的 arraycopy 方法
        System.arraycopy(src,3,dest,1,4); //底层是 native 方式
        //遍历
        for(int i=0;i<dest.length;i++){
            System.out.println(dest[i]);
        }
    }

    /**
     *  自定义的数组拷贝的方法
     * @param src 原数组
     * @param srcPos 原数组开始拷贝的下标
     * @param dest 新数组
     * @param destPos 新数组开始拷贝的下标
     * @param length 拷贝的元素个数
     */
    public static void arraycopy(int[] src,int srcPos,int[] dest,int destPos,int length){
        for(int i=srcPos;i<srcPos+length;i++){
            //dest[destPos] = src[i];
            //destPos++;
            dest[destPos++] = src[i];
        }
    }
}

7. 数组的排序

8. 数组的查找

二、 常用类

1. Arrays工具类

sort()
binarySearch()

2. String

String 类是不可变类

不可以通过继承去重新定义方法,可以定义一个类,包含String类,然后再增强或者实现。

public class StringTest02 {
    public static void main(String[] args) {
        String s1 = "abc";//指向的常量池
        String s2 = "abc";//指向的常量池
        String s3 = new String("abc");//指向的是堆内存
        System.out.println("s1==s2, " + (s1==s2));//true
        System.out.println("s2==s3, " + (s2==s3));//false
        System.out.println("s2 equlas s3," + (s2.equals(s3)));//true
    }
}
  • 当通过new关键字构建的时候,会在堆内存创建一个对象,在常量池创建一份对象,并且变量指向的是堆中对象的地址

定义String时,尽量使用双引号定义,这样可以节约空间,重复利用

注意事项

因为 String 是不可变对象,如果多个字符串进行拼接,将会形成多个对象,这样可能会造成内存溢出,会
给垃圾回收带来工作量,如下面的应用最好不要用 String

常用方法
  • endsWith:判断字符串是否以指定的后缀结束
  • startsWith,判断字符串是否以指定的前缀开始
  • equals, 字符串相等比较,不忽略大小写
  • equalsIgnoreCase,字符串相等比较,忽略大小写
  • indexOf,取得指定字符在字符串的位置
  • lastIndexOf,返向最后一次字符串出现的位置
  • length,取得字符串的长度
  • replaceAll, 替换字符串中指定的内容
  • split,根据指定的表达式拆分字符串
  • substring,截子串
  • trim,去前尾空格
  • valueOf,将其他类型转换成字符串

3. String、StringBuffer 和 StringBuilder

可变性
  • String类定义了final char数组,所以数据是不可变的
  • StringBuffer 和 StringBuilder定义都只是char数组,数据是可变的
线程安全性
  • String是不可变的,所以线程安全
  • StringBuffer内部的方法是加了同步锁,所以线程安全
  • StringBuilder没有加锁,所以线程不安全

线程安全 != 保证拼接顺序

StringBuffer的线程安全只是保证了在一次append()中不会有其他线程进入

性能
  • String是不可变的,每次更改都需要重新创建一个新的对象,所以性能很差
  • StringBuffer因为加锁的缘故,性能比StringBuilder略差10%~15%左右

4. 基本类型对应的包装类

为了保证线程安全,包装类都是不可变类型。

基本类型包装类
byteByte
shortShort
charCharacter
intInteger
longLong
floatFloat
doubleDouble
booleanBoolean
  • 除了 Boolean 和 Character 外,其它的包装类都有 valueOf()和 parseXXX 方法 ,同时都是number的子类

  • 自动装箱和拆箱是JDK1.5之后提供的,方便基本类型与包装类之间的转换

String、 int、 Integer 之间的转换

public class Test {
    public static void main(String[] args) {
        //String + Integer
        Integer a = new Integer("123");
        String b = Integer.toString(123);

        //String + int
        int c = Integer.parseInt("123");
        String d = String.valueOf(c);

        //int + Integer
        Integer e = 123;
        int f = e.intValue();
    }
}

5. 数字类

DecimalFormat
BigDecimal

6. Random

7. Enum

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值