StringBuffer（StringBuilder）_sort()_Arrays

13.01_常见对象(StringBuffer类的概述)

A:StringBuffer类概述
- 通过JDK提供的API，查看StringBuffer类的说明
- 线程安全的可变字符序列
B:StringBuffer和String的区别
- String是一个不可变的字符序列
- StringBuffer是一个可变的字符序列

13.02_常见对象(StringBuffer类的构造方法)

A:StringBuffer的构造方法：
- public StringBuffer():无参构造方法,初始容量大小16字节
- public StringBuffer(int capacity):指定容量的字符串缓冲区对象
- public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
B:StringBuffer的方法：
- public int capacity()：返回当前容量。理论值(不掌握)
- public int length():返回长度（字符数）。实际值
C:案例演示
- 构造方法和长度方法的使用

public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        System.out.println(sb.length());    //0,容器的字符个数
        System.out.println(sb.capacity());  //16，容器的初始容量

        StringBuffer sb1 = new StringBuffer(10);
        System.out.println(sb1.length());   //0,容器的字符个数
        System.out.println(sb1.capacity()); //10，可设置容器的初始容量

        StringBuffer sb2 = new StringBuffer("hongwei");
        System.out.println(sb2.length());   //7,容器的字符个数
        System.out.println(sb2.capacity()); //23，字符个数+容器的初始容量
    }

13.03_常见对象(StringBuffer的添加功能)

A:StringBuffer的添加功能
- public StringBuffer append(String str):
  - 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身，即不管多少操作，操作的都是一个对象。本身发生改变。
    
    注：这是与String的区别。StringBuffer操作的都是本身(subString()除外)，而String操作不影响本身。

        StringBuffer sb_1 = new StringBuffer("abc");
        StringBuffer sb_2 = sb_1.append(100);
        System.out.println(sb_1.toString());    //"abc100"
        System.out.println(sb_2.toString());    //"abc100"

        String s = "abc";
        String s1 = s.substring(1);
        System.out.println(s);  //“abc”
        System.out.println(s1); //"ab"

* public StringBuffer **insert**(int offset,String str):
    * 在offset位置把任意类型的数据str插入到字符串缓冲区里面,并返回字符串缓冲区本身.如果不存在offset位置，报索引越界异常错误。

13.04_常见对象(StringBuffer的删除功能)

A:StringBuffer的删除功能
- public StringBuffer deleteCharAt(int index):
  - 删除指定位置的字符，并返回本身
- public StringBuffer delete(int start,int end):
  - 删除从指定位置开始指定位置结束的内容，并返回本身
  - 删除包括start，不包括尾

13.05_常见对象(StringBuffer的替换和反转功能)

A:StringBuffer的替换功能
- public StringBuffer replace(int start,int end,String str):
  - 从start开始到end用str替换
B:StringBuffer的反转功能
- public StringBuffer reverse():
  - 字符串反转

13.06_常见对象(StringBuffer的截取功能及注意事项)

A:StringBuffer的截取功能
- public String substring(int start):
  - 从指定位置截取到末尾
- public String substring(int start,int end):
  - 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
B:注意事项
- 注意:返回值类型不再是StringBuffer本身

        StringBuffer sb = new StringBuffer("1234");
        sb.append(567);
        System.out.println(sb); //1234567

        sb.insert(3,"hong");
        System.out.println(sb); //123hong4567

        sb.deleteCharAt(3);
        System.out.println(3);  //123ong4567

        sb.delete(3,6);
        System.out.println(sb);//1234567,删除包括start，不包括尾
        //sb.delete(0,sb.length()); //清空缓冲区

        sb.replace(3, 5, "hong");//包含头，不包含尾
        System.out.println(sb);//123hong67

        sb.reverse();
        System.out.println(sb); //76gnoh321

        sb.reverse();
        String s = sb.substring(3, 7);
        System.out.println(sb); //123hong67,注意：返回值不再是本身，包含头，不包含尾
        System.out.println(s);  //hong

13.07_常见对象(StringBuffer和String的相互转换)

A:String – StringBuffer
- a:通过构造方法
- b:通过append()方法
B:StringBuffer – String
- a:通过构造方法
- b:通过toString()方法
- c:通过subString(0,length);

13.08_常见对象(把数组转成字符串)

A:案例演示

需求：把数组中的数据按照指定个格式拼接成一个字符串

举例：
    int[] arr = {1,2,3};
输出结果：
    "[1, 2, 3]"

用StringBuffer的功能实现

private static void formatPrint() {
        //sb.append(arr[i]+"]"); //要再创建一个StringBuffer对象，浪费资源
        //这里使用StringBuffer,只需要创建一次对象。要是使用String对象，后面每次更改值，之前的都变为垃圾，浪费资源。
        StringBuffer sb = new StringBuffer();
        int arr[] ={1,2,3};
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length-1){
                sb.append(arr[i]).append("]");
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        System.out.println(sb);
    }

13.09_常见对象(字符串反转)

A:案例演示

需求：把字符串反转
    举例：键盘录入"abc"
    输出结果："cba"

用StringBuffer的功能实现

public static void main(String[] args) {
        //formatPrint();
        Scanner sc = new Scanner(System.in);
        StringBuffer sb = new StringBuffer(sc.nextLine());
        sb.reverse();
        System.out.println(sb);
    }

13.10_常见对象(StringBuffer和StringBuilder的区别)

A:StringBuilder的概述
- 通过查看API了解一下StringBuilder类
B:面试题
- String,StringBuffer,StringBuilder的区别
- StringBuffer和StringBuilder的区别
- StringBuffer是jdk1.0版本的,是线程安全的,效率低
- StringBuilder是jdk1.5版本的,是线程不安全的,效率高
- String和StringBuffer,StringBuilder的区别
- String是一个不可变的字符序列
- StringBuffer,StringBuilder是可变的字符序列

13.11StringBuffer和String的区别

1.StringBuffer和String的区别**

* String是一个不可变的字符序列

* StringBuffer是一个可变的字符序列

2.常见对象(String和StringBuffer分别作为参数传递)

* A:形式参数问题

* String作为参数传递，虽然是引用数据类型，但是当做参数传递时和基本数据类型是一样的

* StringBuffer作为参数传递

B:案例演示
- String和StringBuffer分别作为参数传递问题

public class Demo4_String_StringBuffer {
    public static void main(String[] args) {
    //String虽然是引用数据类型，但是当做参数传递时和基本数据类型是一样的
        String s = "123";
        change(s);
        System.out.println(s);  //123

        StringBuffer sb = new StringBuffer("123");
        change(sb);
        System.out.println(sb); //123hongwei
    }

    private static void change(StringBuffer sb) {
        sb.append("hongwei");
    }

    private static void change(String s) {
        s+="hongwei";
    }
}

13.12_常见对象(数组高级冒泡排序原理图解)

A:画图演示

需求：
    数组元素：{24, 69, 80, 57, 13}
    请对数组元素进行排序。

    冒泡排序
        相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

private static void sort(int[] arr) {
        for(int i=0;i<arr.length-1;i++)
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j+1]<arr[j]){
                    int temp = arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=temp;
                }
            }
        for (int i : arr) {
            System.out.print(i+" ");
        }
    }

13.14_常见对象(数组高级选择排序原理图解)

A:画图演示
- 需求：
  - 数组元素：{24, 69, 80, 57, 13}
  - 请对数组元素进行排序。
  - 选择排序
    - 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

public static void selectSort(int[] arr) {
        for(int i=0;i<arr.length;i++){
            int k=i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[i]){
                    if(arr[j]<arr[k]){
                        k=j;
                    }
                }
            }
            int temp =arr[i];
            arr[i]=arr[k];
            arr[k]=temp;
        }
    }

或者

    public static void selectSort1(int[] arr) {
        for(int i=0;i<arr.length;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[i]){
                    int temp =arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }

        }
    }

13.16_常见对象(数组高级二分查找原理图解)

A:画图演示
- 二分查找
- 前提：数组元素有序
B:注意事项
- 如果数组无序，就不能使用二分查找。
  - 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

public static void main(String[] args) {
        int[] arr ={1,5,8,13,59};
        System.out.println(binaryFind(arr,8));
    }

    public static int binaryFind(int[] arr,int value) {
        int min=0;
        int max=arr.length-1;
        int mid = (min+max)/2;
        while(arr[mid]!=value){
            if(arr[mid]<value){
                min = min+1;
            }else if(arr[mid]>value){
                max=max-1;
            }
            mid = (min+max)/2;
            if(min>max){
                return -1;
            }
        }
        return mid;
    }

13.18_常见对象(Arrays类的概述和方法使用)

A:Arrays类概述
- 针对数组进行操作的工具类。
- 提供了排序，查找等功能。
B:成员方法
- public static String toString(int[] a)将数组转为字符串
- public static void sort(int[] a)，排序，底层使用快速排序
- public static int binarySearch(int[] a,int key)
- 找到返回索引，否则返回-（插入点）-1

13.19_常见对象(基本类型包装类的概述)

A:为什么会有基本类型包装类
- 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
B:常用操作
- 常用的操作之一：用于基本数据类型与字符串之间的转换。
C:基本类型和包装类的对应
byte Byte
short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

13.20_常见对象(Integer类的概述和构造方法)

A:Integer类概述
- 通过JDK提供的API，查看Integer类的说明
- Integer 类在对象中包装了一个基本类型 int 的值,
- 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
- 还提供了处理 int 类型时非常有用的其他一些常量和方法
B:构造方法
- public Integer(int value)
- public Integer(String s)
C:案例演示
- 使用构造方法创建对象

13.21_常见对象(String和int类型的相互转换)

A:int – String
- a:和”“进行拼接
- b:public static String valueOf(int i)
- String s = String.valueOf(i);
- c:int – Integer – String(Integer类的toString方法())
- d:public static String toString(int i)(Integer类的静态方法)
B:String – int
- a:String – Integer – int

Integer i1 = new Integer("100");
int i2=i1.intValue();

* public static int **parseInt**(String s)

基本数据类型包装类有八中，其中有七个有parseXxx()，可以将这其中的字符串表现形式转化为基本数据类型

char没哟，字符串转为字符数组，用toCharArray()

13.22_常见对象(JDK5的新特性自动装箱和拆箱)

A:JDK5的新特性
- 自动装箱：把基本类型转换为包装类类型
- 自动拆箱：把包装类类型转换为基本类型
B:案例演示
- JDK5的新特性自动装箱和拆箱
- Integer ii = 100; //自动装箱
- ii += 200; //自动拆箱，
C:注意事项
- 在使用时，Integer x = null;代码就会出现NullPointerException。
- 建议先判断是否为null，然后再使用。

13.23_常见对象(Integer的面试题)

A:Integer的面试题

看程序写结果

Integer i1 = new Integer(97);
Integer i2 = new Integer(97);
System.out.println(i1 == i2);//false
System.out.println(i1.equals(i2));//true
System.out.println("-----------");

Integer i3 = new Integer(197);
Integer i4 = new Integer(197);
System.out.println(i3 == i4);//false
System.out.println(i3.equals(i4));
System.out.println("-----------");

Integer i5 = 97;
Integer i6 = 97;
System.out.println(i5 == i6);//true
System.out.println(i5.equals(i6));
System.out.println("-----------");

Integer i7 = 197;
Integer i8 = 197;
System.out.println(i7 == i8);//false
System.out.println(i7.equals(i8));

-128到127是byte的取值范围，如果在这个取值范围内，自动装箱就不会创建新的对象，直接在常量池中获取；

如果超过byte的取值范围，就会再新创建对象

13.24_day13总结

把今天的知识点总结一遍。

时间： 2024-10-11 00:22:19

StringBuffer（StringBuilder）_sort()_Arrays的相关文章

Java 字符串生成器（StringBuilder）

删除服务一般有两个办法: 办法一: 用sc.exe这个Windows命令开始--运行--cmd.exe,然后输入sc就可以看到了.使用办法很简单: sc delete"服务名" (如果服务名中间有空格,就需要前后加引号) 如针对上面的: sc delete ConnectMON 办法二:直接进行注册表编辑打开注册表编辑器,找到下面的键值: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services 一般服

探秘Java中的String、StringBuilder以及StringBuffer（转载）

探秘Java中String.StringBuilder以及StringBuffer 相信String这个类是Java中使用得最频繁的类之一,并且又是各大公司面试喜欢问到的地方,今天就来和大家一起学习一下String.StringBuilder和StringBuffer这几个类,分析它们的异同点以及了解各个类适用的场景.下面是本文的目录大纲: 一.你了解String类吗? 二.深入理解String.StringBuffer.StringBuilder 三.不同场景下三个类的性能测试四.常见的关于

字符串（String、StringBuffer、StringBuilder）

一.String 首先我们要明确,String并不是基本数据类型,而是一个对象,并且是不可变的对象.查看源码就会发现String类为final型的(当然也不可被继承),而且通过查看JDK文档会发现几乎每一个修改String对象的操作,实际上都是创建了一个全新的String对象. 字符串为对象,那么在初始化之前,它的值为null,到这里就有必要提下"".null.new String()三者的区别.null 表示string还没有new ,也就是说对象的引用还没有创建,也没有分配内存空间

JAVA基础知识总结14（String、StringBuffer、StringBuilder）

1.String字符串: java中用String类进行描述.对字符串进行了对象的封装.这样的好处是可以对字符串这种常见数据进行方便的操作.对象封装后,可以定义N多属性和行为. 如何定义字符串对象呢?String s = "abc";只要是双引号引起的数据都是字符串对象. 特点:字符串一旦被初始化,就不可以被改变,存放在方法区中的常量池中. String s1 = "abc"; // s1指向的内存中只有一个对象abc. String s2 = new String

Java入门系列之StringBuilder、StringBuffer（三）

前言上一节我们讲解了字符串的特性,除了字符串类外,还有两个我们也会经常用到的类,那就是StringBuffer和StringBuilder.因为字符串不可变,所以我们每次对字符串的修改比如通过连接concat.trim等都会创建一个新的字符串对象,那么我们如何在不创建字符串垃圾(大量临时的字符串)的情况下操作字符串呢?答案则是使用StringBuffer和StringBuilder,StringBuffer是旧类,但是在Java 5中新增了StringBuilder,并且在Enum,Gene

理解Java（StringBuffer和StringBuilder）

StringBuffer可实现同步,StringBuilder线程不安全. 翻译自Java API英文文档本质 StringBuffer 和 StringBuilder 均表示一个可变字符序列这个字符序列是一个类似 String 的字符串缓冲区,但能被修改区别当字符串缓冲区用于单线程环境时,采用 StringBuilder 若需要同步时,则使用 StringBuffer,因为 StringBuffer 是线程安全的也就是说,StringBuilder 是 StringBuffer 在单

字符串使用（String，StringBuffer，StringBuilder）

一.区别: String:String创建的字符串是不可变的,当使用String创建一个字符串后,该字符串在内存中是一个不可改变的字符串,如果改变字符串变量的汉子,其实际是在内存中创建一个新的字符串,字符串变量将引用新创建的字符串地址,而原来的字符串在内存中依然存在且内容不变,直到JAVA的垃圾回收系统对其进行销毁. StringBuffer创建的字符串是可变的,当使用SringBuffer创建一个字符后,该字符的内容可以通过append().insert().setCharAt()等方法进行改

String、StringBuffer与StringBuilder之间区别（转载）

最近学习到StringBuffer,心中有好些疑问,搜索了一些关于String,StringBuffer,StringBuilder的东西,现在整理一下. 关于这三个类在字符串处理中的位置不言而喻,那么他们到底有什么优缺点,到底什么时候该用谁呢?下面我们从以下几点说明一下 1.三者在执行速度方面的比较:StringBuilder > StringBuffer > String 2.String <(StringBuffer,StringBuilder)的原因 String:字符串常