JAVA中String拓展以及数组

最新推荐文章于 2023-01-09 08:20:12 发布

贤狼ww

最新推荐文章于 2023-01-09 08:20:12 发布

阅读量185

点赞数

分类专栏： java学习文章标签： java 字符串

本文链接：https://blog.csdn.net/helo0507/article/details/116741766

版权

java学习专栏收录该内容

18 篇文章 0 订阅

订阅专栏

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

贤狼ww

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA中String拓展以及数组

Sting类与数组1.StringBuffer类StringBuffer类——线程安全的可变字符序列StringBuffer的构造方法public StringBuffer(): 无参构造方法public StringBuffer(int capacity): 指定容量public StringBuffer(String str): 指定字符串内容StringBuffer的方法：public int capacity()
复制链接

扫一扫