Java字符串操作系列(2)

1、字符串性能比较测试

以下实例演示了通过两种方式创建字符串,并测试其性能:

public class StringComparePerformance{
   public static void main(String[] args){      
      long startTime = System.currentTimeMillis();
      for(int i=0;i<50000;i++){
         String s1 = "hello";
         String s2 = "hello"; 
      }
      long endTime = System.currentTimeMillis();
      System.out.println("通过 String 关键词创建字符串" 
      + " : "+ (endTime - startTime) 
      + " 毫秒" );       
      long startTime1 = System.currentTimeMillis();
      for(int i=0;i<50000;i++){
         String s3 = new String("hello");
         String s4 = new String("hello");
      }
      long endTime1 = System.currentTimeMillis();
      System.out.println("通过 String 对象创建字符串" 
      + " : " + (endTime1 - startTime1)
      + " 毫秒");
   }
}

以上代码实例输出结果为:

通过 String 关键词创建字符串 : 6 毫秒 
通过 String 对象创建字符串 : 14 毫秒

用关键字创建对象时,由于JAVA堆中常量池的存在,在第一个字符串字面值常量"hello"被加入到常量池之后,,后续字符串的创建就无需重新开辟空间了,只需要另引用变量指向常量池中的"hello"即可完成。

用new关键字创建对象时,由于每次都需要在堆空间中开辟空间,因此浪费的时间比第一种要多得多

2、字符串优化

以下实例演示了通过 String.intern() 方法来优化字符串:

public class StringOptimization {
    public static void main(String[] args){
        String variables[] = new String[50000];      
        for( int i=0;i <50000;i++){
            variables[i] = "s"+i;
        }
        long startTime0 = System.currentTimeMillis();
        for(int i=0;i<50000;i++){
            variables[i] = "hello";
        }
        long endTime0 = System.currentTimeMillis();
        System.out.println("直接使用字符串: "+ (endTime0 - startTime0)  + " ms" );
        long startTime1 = System.currentTimeMillis();
            for(int i=0;i<50000;i++){
            variables[i] = new String("hello");
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println("使用 new 关键字:" + (endTime1 - startTime1) + " ms");
        long startTime2 = System.currentTimeMillis();
        for(int i=0;i<50000;i++){
            variables[i] = new String("hello");
            variables[i] = variables[i].intern();          
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("使用字符串对象的 intern() 方法: " 
        + (endTime2 - startTime2)
        + " ms");
    }
}

以上代码实例输出结果为:

直接使用字符串: 3 ms
使用 new 关键字:5 ms
使用字符串对象的 intern() 方法: 10 ms

3、字符串格式化

以下实例演示了通过 format() 方法来格式化字符串,还可以指定地区来格式化:

import java.util.*;

public class StringFormat {
    public static void main(String[] args){
        // 获取数学常数e的值
        double e = Math.E;
        
        // 以浮点数形式打印出e的值
        System.out.format("%f%n", e);
        
        // 指定本地为中国(CHINA),并以浮点数形式打印出e的值
        System.out.format(Locale.CHINA, "%-10.4f%n%n", e);
    }
}

以上代码实例输出结果为:

2.718282
2.7183  

4、连接字符串

以下实例演示了通过 "+" 操作符和StringBuffer.append() 方法来连接字符串,并比较其性能:

    public static void main(String[] args){
        long startTime = System.currentTimeMillis();
        for(int i=0;i<50000;i++){
            String result = "";
                    result += "This is";
                    result += "testing the";
                    result += "difference";
                    result += "between";
                    result += "String";
                    result += "and";
                    result += "StringBuffer";
        }
        long endTime = System.currentTimeMillis();
        System.out.println("字符串连接"
                + " - 使用 + 操作符 : "
                + (endTime - startTime)+ " ms");
        long startTime1 = System.currentTimeMillis();
        for(int i=0;i<50000;i++){
            StringBuffer result = new StringBuffer();
            result.append("This is");
            result.append("testing the");
            result.append("difference");
            result.append("between");
            result.append("String");
            result.append("and");
            result.append("StringBuffer");
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println("字符串连接"
                + " - 使用 StringBuffer : "
                + (endTime1 - startTime1)+ " ms");

        long startTime2 = System.currentTimeMillis();
        for(int i=0;i<50000;i++){
            StringBuilder result = new StringBuilder();
            result.append("This is");
            result.append("testing the");
            result.append("difference");
            result.append("between");
            result.append("String");
            result.append("and");
            result.append("StringBuffer");
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("字符串连接"
                + " - 使用 StringBuilder : "
                + (endTime2 - startTime2)+ " ms");
    }

以上代码实例输出结果为

测试结果如下,可以看出就拼接效率而言,String < StringBuffer < StringBuilder。

字符串连接 - 使用 + 操作符 : 90 ms

字符串连接 - 使用 StringBuffer : 20 ms

字符串连接 - 使用 StringBuilder : 10 ms

对于“+”来说,会在常量池中创建了多个String对象,占用内存

首先第一种测试”+“号,每次相加的过程String类由于是不可变序列,都会默认在堆中new了一个新对象来存放相加之后的字符串,这个过程是时间差的主要原因。而StringBuilder & StringBuffer有时间差的主要原因在于,一个是线程不安全的类,一个是线程安全的类,Buffer要保证方法的线程安全自然效率会变低。

5、数组排序及元素查找

以下实例演示了如何使用sort()方法对Java数组进行排序,及如何使用 binarySearch() 方法来查找数组中的元素, 这边我们定义了 printArray() 方法来打印数组:

import java.util.Arrays;

public class MainClass {
    public static void main(String args[]) throws Exception {
        int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
        Arrays.sort(array);
        printArray("数组排序结果为", array);
        int index = Arrays.binarySearch(array, 2);
        System.out.println("元素 2  在第 " + index + " 个位置");
    }
    private static void printArray(String message, int array[]) {
        System.out.println(message
        + ": [length: " + array.length + "]");
        for (int i = 0; i < array.length; i++) {
            if(i != 0){
                System.out.print(", ");
            }
            System.out.print(array[i]);
        }
        System.out.println();
    }
}

以上代码运行输出结果为:

数组排序结果为: [length: 10] -9, -7, -3, -2, 0, 2, 4, 5, 6, 8
元素 2 在第 5 个位置

7、数组添加元素

以下实例演示了如何使用sort()方法对Java数组进行排序,及如何使用 insertElement () 方法向数组插入元素, 这边我们定义了 printArray() 方法来打印数组:

import java.util.Arrays;

public class MainClass {
   public static void main(String args[]) throws Exception {
      int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
      Arrays.sort(array);
      printArray("数组排序", array);
      int index = Arrays.binarySearch(array, 1);
      System.out.println("元素 1 所在位置(负数为不存在):"+ index);  
      int newIndex = -index - 1;
      array = insertElement(array, 1, newIndex);
      printArray("数组添加元素 1", array);
   }
   private static void printArray(String message, int array[]) {
      System.out.println(message + ": [length: " + array.length + "]");
      for (int i = 0; i < array.length; i++) {
         if (i != 0){
            System.out.print(", ");
         }
         System.out.print(array[i]);         
      }
      System.out.println();
   }
   private static int[] insertElement(int original[],
   int element, int index) {
      int length = original.length;
      int destination[] = new int[length + 1];
      System.arraycopy(original, 0, destination, 0, index);
      destination[index] = element;
      System.arraycopy(original, index, destination, index+ 1, length - index);
      return destination;
   }
}

以上代码运行输出结果为:

数组排序: [length: 10] -9, -7, -3, -2, 0, 2, 4, 5, 6, 8 
元素 1 所在位置(负数为不存在):-6 
数组添加元素 1: [length: 11] -9, -7, -3, -2, 0, 1, 2, 4, 5, 6, 8

System.arraycopy()是Java中的一个方法,用于将一个数组的一部分复制到另一个数组中。它的基本语法如下:

System.arraycopy(源数组, 源数组开始位置, 目标数组, 目标数组开始位置, 复制长度);
 

 
  

参数说明:

  • 源数组:要复制的数组。
  • 源数组开始位置:从源数组的哪个位置开始复制。
  • 目标数组:将复制的内容放入的目标数组。
  • 目标数组开始位置:从目标数组的哪个位置开始放置复制的内容。
  • 复制长度:要复制的元素数量。

示例代码:

public class ArrayCopyDemo {
    public static void main(String[] args) {
        int[] srcArray = {1, 2, 3, 4, 5};
        int[] destArray = new int[5];

        System.arraycopy(srcArray, 1, destArray, 2, 3);

        for (int i : destArray) {
            System.out.print(i + " ");
        }
    }
}
 
  

输出结果

0 0 2 3 4
 

8、获取数组长度

本文我们将为大家介绍如何使用数组的属性 length 来获取数组的长度。

以下实例中我们定义了二维数组,并获取数组的长度:

public class Main {
   public static void main(String args[]) {
      String[][] data = new String[2][5];
      System.out.println("第一维数组长度: " + data.length);
      System.out.println("第二维数组长度: " + data[0].length);
   }
}

以上代码运行输出结果为:

第一维数组长度: 2 
第二维数组长度: 5

9、数组反转

以下实例中我们使用 Collections.reverse(ArrayList) 将数组进行反转:

import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("A");
        arrayList.add("B");
        arrayList.add("C");
        arrayList.add("D");
        arrayList.add("E");
        System.out.println("反转前排序: " + arrayList);
        Collections.reverse(arrayList);
        System.out.println("反转后排序: " + arrayList);
    }
}

以上代码运行输出结果为:

反转前排序: [A, B, C, D, E] 
反转后排序: [E, D, C, B, A] 

10、数组输出

以下实例演示了如何通过循环输出数组:

public class Welcome {
    public static void main(String[] args){
        String[] nowcoders = new String[3];
        nowcoders[0] = "牛客教程";
        nowcoders[1] = "牛客工具";
        nowcoders[2] = "牛客笔记";
        for (int i = 0; i < nowcoders.length; i++){
            System.out.println(nowcoders[i]);
        }
    }
}

以上代码运行输出结果为:

牛客教程
牛客工具
牛客笔记

11、数组获取最大和最小值

以下实例演示了如何通过 Collections 类的 Collections.max() 和 Collections.min() 方法来查找数组中的最大和最小值:

import java.util.Arrays;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        Integer[] numbers = { 8, 2, 7, 1, 4, 9, 5};
        int min = (int) Collections.min(Arrays.asList(numbers));
        int max = (int) Collections.max(Arrays.asList(numbers));
        System.out.println("最小值: " + min);
        System.out.println("最大值: " + max);
    }
}

以上代码运行输出结果为:

最小值: 1
最大值: 9

12、数组合并

以下实例演示了如何通过 List 类的 Arrays.toString () 方法和 List 类的 list.Addall(array1.asList(array2) 方法将两个数组合并为一个数组:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String args[]) {
        String a[] = { "A", "E", "I" };
        String b[] = { "O", "U" };
        List list = new ArrayList(Arrays.asList(a));
        list.addAll(Arrays.asList(b));
        Object[] c = list.toArray();
        System.out.println(Arrays.toString(c));
    }
}

以上代码运行输出结果为:

[A, E, I, O, U]

13、数组填充

以下实例我们通过 Java Util 类的 Arrays.fill(arrayname,value) 方法和Arrays.fill(arrayname ,starting index ,ending index ,value) 方法向数组中填充元素:

import java.util.*;

public class FillTest {
    public static void main(String args[]) {
        int array[] = new int[6];
        Arrays.fill(array, 100);
        for (int i=0, n=array.length; i < n; i++) {
            System.out.println(array[i]);
        }
        System.out.println();
        Arrays.fill(array, 3, 6, 50);
        for (int i=0, n=array.length; i< n; i++) {
            System.out.println(array[i]);
        }
    }
}

以上代码运行输出结果为:

100
100
100
100
100
100

100
100
100
50
50
50

14、数组扩容

以下实例演示了如何在数组初始化后对数组进行扩容:

public class Main {
    public static void main(String[] args) {
        String[] names = new String[] { "A", "B", "C" };
        String[] extended = new String[5];
        extended[3] = "D";
        extended[4] = "E";
        System.arraycopy(names, 0, extended, 0, names.length);
        for (String str : extended){
            System.out.println(str);
        }
    }
}

以上代码运行输出结果为:

A
B
C
D
E

15、查找数组中的重复元素

以下实例演示了如何在 java 中找到重复的元素:

public class MainClass {
    public static void main(String[] args) 
    {
        int[] my_array = {1, 2, 5, 5, 6, 6, 7, 2, 9, 2};
        findDupicateInArray(my_array);

    }

    public static void findDupicateInArray(int[] a) {
        int count=0;
        for(int j=0;j

以上代码运行输出结果为:

重复元素 : 5
重复元素 : 6
重复元素 : 2

16、删除数组元素

以下实例演示了如何使用 remove () 方法来删除数组元素:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args)  {
        ArrayList objArray = new ArrayList();
        objArray.clear();
        objArray.add(0,"第 0 个元素");
        objArray.add(1,"第 1 个元素");
        objArray.add(2,"第 2 个元素");
        System.out.println("数组删除元素前:"+objArray);
        objArray.remove(1);
        objArray.remove("第 0 个元素");
        System.out.println("数组删除元素后:"+objArray);
    }
}

以上代码运行输出结果为:

数组删除元素前:[第 0 个元素, 第 1 个元素, 第 2 个元素]
数组删除元素后:[第 2 个元素]

17、数组差集

以下实例演示了如何使用 removeAll () 方法来计算两个数组的差集:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args)  {
        ArrayList objArray = new ArrayList();
        ArrayList objArray2 = new ArrayList();
        objArray2.add(0,"common1");
        objArray2.add(1,"common2");
        objArray2.add(2,"notcommon");
        objArray2.add(3,"notcommon1");
        objArray.add(0,"common1");
        objArray.add(1,"common2");
        objArray.add(2,"notcommon2");
        System.out.println("array1 的元素" +objArray);
        System.out.println("array2 的元素" +objArray2);
        objArray.removeAll(objArray2);
        System.out.println("array1 与 array2 数组差集为:"+objArray);
    }
}

以上代码运行输出结果为:

array1 的元素[common1, common2, notcommon2]
array2 的元素[common1, common2, notcommon, notcommon1]
array1 与 array2 数组差集为:[notcommon2]

18、数组交集

以下实例演示了如何使用 retainAll () 方法来计算两个数组的交集:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args)  {
        ArrayList objArray = new ArrayList();
        ArrayList objArray2 = new ArrayList();
        objArray2.add(0,"common1");
        objArray2.add(1,"common2");
        objArray2.add(2,"notcommon");
        objArray2.add(3,"notcommon1");
        objArray.add(0,"common1");
        objArray.add(1,"common2");
        objArray.add(2,"notcommon2");
        System.out.println("array1 数组元素:"+objArray);
        System.out.println("array2 数组元素:"+objArray2);
        objArray.retainAll(objArray2);
        System.out.println("array2 & array1 数组交集为:"+objArray);
    }
}

以上代码运行输出结果为:

array1 数组元素:[common1, common2, notcommon2]
array2 数组元素:[common1, common2, notcommon, notcommon1]
array2 & array1 数组交集为:[common1, common2]

19、在数组中查找指定元素

以下实例演示了如何使用 contains () 方法来查找数组中的指定元素:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args)  {
        ArrayList objArray = new ArrayList();
        ArrayList objArray2 = new ArrayList();
        objArray2.add(0,"common1");
        objArray2.add(1,"common2");
        objArray2.add(2,"notcommon");
        objArray2.add(3,"notcommon1");
        objArray.add(0,"common1");
        objArray.add(1,"common2");
        System.out.println("objArray 的数组元素:"+objArray);
        System.out.println("objArray2 的数组元素:"+objArray2);
        System.out.println("objArray 是否包含字符串common2? : "
        +objArray.contains("common2"));
        System.out.println("objArray2 是否包含数组 objArray? :"
        +objArray2.contains(objArray) );
    }
}

以上代码运行输出结果为:

objArray 的数组元素:[common1, common2]
objArray2 的数组元素:[common1, common2, notcommon, notcommon1]
objArray 是否包含字符串common2? : true
objArray2 是否包含数组 objArray? :false

为什么objArray2 是否包含数组 objArray?

结果为false

同学,需要使用containsAll()方法,就可以判断的

20、判断数组是否相等

以下实例演示了如何使用 equals ()方法来判断数组是否相等:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws Exception {
        int[] ary = {1,2,3,4,5,6};
        int[] ary1 = {1,2,3,4,5,6};
        int[] ary2 = {1,2,3,4};
        System.out.println("数组 ary 是否与数组 ary1相等? :"
        +Arrays.equals(ary, ary1));
        System.out.println("数组 ary 是否与数组 ary2相等? :"
        +Arrays.equals(ary, ary2));
    }
}

以上代码运行输出结果为:

数组 ary 是否与数组 ary1相等? :true
数组 ary 是否与数组 ary2相等? :false

今天到这里,持续更新。

你可能感兴趣的:(Java基础,java,开发语言,java字符串操作)