Sting类与数组
1.StringBuffer类
- StringBuffer类——线程安全的可变字符序列
- StringBuffer的构造方法
- public StringBuffer(): 无参构造方法
- public StringBuffer(int capacity): 指定容量
- public StringBuffer(String str): 指定字符串内容
- StringBuffer的方法：
public int capacity() 返回当前容量（总容量）
public int length() 返回长度（字符数） - StringBuffer的添加功能
- public StringBuffer append(String str) 把任意类型数据添加到字符串缓冲区里面（返回本身）
- public StringBuffer insert(int offset,String str) 在指定位置插入（返回字符串本身）
- StringBuffer的删除功能
- public StringBuffer deleteCharAt(int index) 删除指定位置的字符，并返回本身
- public StringBuffer delete(int start,int end) 删除从指定位置开始指定位置结束的内容，并返回本身**（含头不含尾）**
- StringBuffer的替换和反转功能
- StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str) 从start开始到end用str替换（含头不含尾） - StringBuffer的反转功能
public StringBuffer reverse() 字符串反转
- StringBuffer的查找功能
- int indexOf (String str) 从前往后查找，到第一次查找截止
- int indexOf (String str,int fromIndex) 从指定处查找
- int lastIndexOf (String str) 从后往前查找
- int lastIndexOf (String str,int fromIndex) 从指定处查找
- StringBuffer的截取功能
- StringBuffer的截取功能
public String substring(int start): 从指定位置截取到末尾
public String substring(int start,int end): 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
- 返回值类型不再是StringBuffer本身，而是String类型
- StringBuffer和String的相互转换
- String – StringBuffer
- StringBuffer sb= new StringBuffer(s);
- StringBuffer – String
- String s=new sb.toString();
- 把数组转成字符串
- 字符串反转
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc= new Scanner(System.in);
System.out.println("输入字符串");
String s= sc.nextLine();
StringBuffer sb= new StringBuffer(s);
sb.reverse();
System.out.println(sb);
}
}2.StringBuffer和StringBuilder的区别
- StringBuffer ——线程安全，效率低
- StringBuilder——线程不安全，效率高
3.传参问题：String和StringBuffer
- String作为参数传递—— String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递
- 案例演示
public class Test {
public static void main(String[] args) {
String str="hi";
test(str);
System.out.println(str);//2.hi
StringBuilder sb = new StringBuilder("abc");
test(sb);
System.out.println(sb.toString());//3.bbbcba
}
? private static void test(StringBuilder sb) {
? sb.append("bbb");
? sb.reverse();
? }
? private static void test(String s) {
? s+="M";
? System.out.println(s); //1.hiM
? }
}4.StringJoiner方法
- StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
构建了一个字符容器，指定分隔符，前缀，后缀 - StringJoiner add(CharSequence newElement)
增加了一份给 CharSequence值的 StringJoiner价值的下一个元素。
5.数组高级冒泡排序代码
public class Maopao {
public static void main(String[] args) {
int[] arr = {4, 5, 78, 55, 67, 99};
for (int j = 1; j < arr.length-1; j++) {
for(int i=0;i<arr.length-j;i++){
if(arr[i]>arr[i+1]){
int t=arr[i];
arr[i]=arr[i+1];
arr[i+1]=t;
}
}
}
System.out.println(Arrays.toString(arr));
}
}6.数组高级选择排序代码
import java.util.Arrays;
public class Xuanze {
public static void main(String[] args) {
int[] arr={4,8,56,76,99,38};
for(int index=0;index<arr.length-1;index++){
for(int i=1+index;i<arr.length;i++){
if(arr[i]<arr[index]){
int t=arr[i];
arr[i]=arr[index];
arr[index]=t;
}
}
}
System.out.println(Arrays.toString(arr));
}
}//将最小数往前排，每次按顺序往后比较7.直接插入排序
import java.util.Arrays;
public class Zhijie {
public static void main(String[] args) {
int[] arr={3,6,7,4,55,90,-2,-8};
for(int i=1;i<arr.length;i++){
int j=i;
while(j>0&&arr[j]<arr[j-1]){
int t=arr[j];
arr[j]=arr[j-1];
arr[j-1]=t;
j--;
}
}
System.out.println(Arrays.toString(arr));
}
}
//从1索引处开始，把后面元素插入到之前一个有序序列，使仍有序8.快速排序
public class QuickSortUtils {
//快速排序的方法
public static void quickSort(int[] arr, int start, int end) {
//找出基准数位置，分成左右两区
if (start < end) {
//找出基准数位置
int index = getIndex(arr, start, end);
//对左区进行递归
quickSort(arr, start, index - 1);
//对右区进行递归
quickSort(arr, index + 1, end);
}
}
///*
// 挖坑填数
// 1.将基准数挖出形成第一个坑。
// 2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
// 3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
// 4.再重复执行2，3两步骤。
// */
private static int getIndex(int[] arr, int start, int end) {
int i = start;
int j = end;
//1.将基准数挖出形成第一个坑。
int x = arr[i];
while (i < j) { //4.再重复执行2，3两步骤。
//2. 由后向前找比他小的数，找到后挖出此数填到前一个坑中。
while (i < j && arr[j] >= x) { //8 > 5 0>5
j--; //找出比基准数小的那个元素的位置
}
if (i < j) {
//找到后挖出此数填到前一个坑中。
arr[i] = arr[j];
i++; //顺便让i递增一下
}
//3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
while (i < j && arr[i] < x) {
i++;
}
if (i < j) {
//找到后挖出此数填到前一个坑中。
arr[j] = arr[i];
j--; //顺便让j递减一下
}
}
arr[i] = x; //把基准数填到最后一个坑位中
//arr[j] = x;
//i和j重合了，i和j相等
return j;
}
}
//执行方法
package org.westos.demo4;
import java.util.Arrays;
public class MyTest {
public static void main(String[] args) {
int[] arr = {24, 6, 80, 57, 13, 2, 0, 3, 8, 200, -4, 5, 0, 500, 20};
//使用快速排序
QuickSortUtils.quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
}9.二分查找
public class MyTest {
public static void main(String[] args) {
//查找该元素第一次出现的索引
int[] arr = {10, 20, 30, 50, 50, 50, 50, 60, 70, 80, 90, 100};
//基本查找
// int index = getIndex(arr, 24);
// System.out.println(index);
//二分查找：前提是数组元素有序
//二分查找，他不是找该元素第一个出现的索引
int index = getIndex2(arr, 50);
System.out.println(index);
}
//二分查找
private static int getIndex2(int[] arr, int ele) {
//定义三个变量
int minIndex = 0;
int maxIndex = arr.length - 1;
int centerIndex = (minIndex + maxIndex) / 2;
while (minIndex <= maxIndex) {
if (ele == arr[centerIndex]) {
return centerIndex;
} else if (ele > arr[centerIndex]) {
minIndex = centerIndex + 1;
} else if (ele < arr[centerIndex]) {
maxIndex = centerIndex - 1;
}
//重新计算中间索引
centerIndex = (minIndex + maxIndex) / 2;
}
return -1;
}
private static int getIndex(int[] arr, int ele) {
for (int i = 0; i < arr.length; i++) {
if (ele == arr[i]) {
return i;
}
}
return -1;
}
}10.Arrays类
- Arrays类是针对数组进行操作的工具类。提供了排序，查找等功能。
- 成员方法
- public static String toString(int[] a) 将数组转换成字符串
- public static void sort(int[] a) 升序排序（必须有序）
- public static int binarySearch(int[] a,int key) 二分查找的快速调用，查找某个数值所在的索引
- static boolean equals(int[] a, int[] a2) 比较两个数组中的元素，是否一样
- static int[] copyOf(int[] original, int newLength) 复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组
- static int[] copyOfRange(int[] original, int from, int to) 复制旧数组中的起始索引到终止索引
11.基本类型包装类
- 为什么会有基本类型包装类
为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型. - 常用操作: 用于基本数据类型与字符串之间的转换。
- 基本类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
12.Integer类
- Integer 类在对象中包装了一个基本类型 int 的值
该类提供了多个方法，能在 int 类型和 String 类型之间互相转换。 - 构造方法
public Integer(int value)
public Integer(String s) //要个一个字面上是数字的字符串，如果不是就会报错 - 案例演示
public class MyTest {
public static void main(String[] args) {
int num = 100;
String s = Integer.toBinaryString(num);//转换成2进制
String s1 = Integer.toOctalString(num);//转换成8进制
String s2 = Integer.toHexString(num);//转换成16进制
System.out.println(s);
System.out.println(s1);
System.out.println(s2);
int maxValue = Integer.MAX_VALUE;
int minValue = Integer.MIN_VALUE;//最大值
System.out.println(maxValue);
System.out.println(minValue);
}
}13.String和int类型的相互转换
- int 转换成String
- 与空串进行拼接
- String s= String.valueof(num)
- String 转换成 int
- int i= Integer.parseInt(str2)
- int I=Integer.intValue(str1)
14.新特性自动装箱和拆箱
- 自动装箱：把基本类型转换为包装类类型
- 自动拆箱：把包装类类型转换为基本类型
Integer ii = 100;//自动装箱
ii += 200;//自动拆箱再自动装箱。15.Integer的面试题
A:Integer的面试题
看程序写结果
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//false
System.out.println(i1.equals(i2));//true
System.out.println("-----------");
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);//false
System.out.println(i3.equals(i4));//true
System.out.println("-----------");
Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);//false
System.out.println(i5.equals(i6));//true
System.out.println("-----------");
Integer i7 = 127;
Integer i8 = 127;
System.out.println(i7 == i8);//true
System.out.println(i7.equals(i8));//false
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
