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<String> arrayList = new ArrayList<String>();
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
100100
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<a.length;j++) {
for(int k =j+1;k<a.length;k++) {
if(a[j]==a[k]) {
count++;
}
}
if(count==1)
System.out.println( "重复元素 : " + a[j] );
count = 0;
}
}
}以上代码运行输出结果为：
重复元素 : 5
重复元素 : 6
重复元素 : 2
16、删除数组元素
以下实例演示了如何使用 remove () 方法来删除数组元素：
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<String> objArray = new ArrayList<String>();
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<String> objArray = new ArrayList<String>();
ArrayList<String> objArray2 = new ArrayList<String>();
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
今天到这里，持续更新。
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！