javaday13-StringBuffer.数组

最新推荐文章于 2022-06-23 12:52:54 发布
最新推荐文章于 2022-06-23 12:52:54 发布
阅读量4.2k 收藏 3
点赞数 4
分类专栏： java基础教学 文章标签： java string api
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kairui007/article/details/50158367
版权

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

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

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

  • A:StringBuffer的构造方法：
    • public StringBuffer():无参构造方法
    • public StringBuffer(int capacity):指定容量的字符串缓冲区对象
    • public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
  • B:StringBuffer的方法：
    • public int capacity()：返回当前容量。 理论值(不掌握)
    • public int length():返回长度（字符数）。 实际值

  • C:案例演示

    • 构造方法和长度方法的使用

    public class Demo1_StringBuffer {

    public static void main(String[] args) {

    StringBuffer sb = new StringBuffer();
    System.out.println(sb.length());            //容器中的字符个数,实际值
    System.out.println(sb.capacity());          //容器的初始容量,理论值

    StringBuffer sb2 = new StringBuffer(10);
    System.out.println(sb2.length());
    System.out.println(sb2.capacity());

    StringBuffer sb3 = new StringBuffer("heima");
    System.out.println(sb3.length());           //实际字符的个数
    System.out.println(sb3.capacity());         //字符串的length + 初始容量

}

    }

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

  • A:StringBuffer的添加功能

    • public StringBuffer append(String str):
      • 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
    • public StringBuffer insert(int offset,String str):
      • 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

    public class Demo2_StringBuffer {

    public static void main(String[] args) {

    //demo1();
StringBuffer sb = new StringBuffer("1234");
sb.insert(3, "heima");                      //在指定位置添加元素,如果没有指定位置的索引就会报索引越界异常

System.out.println(sb);

    }

    private static void demo1() {

    StringBuffer sb = new StringBuffer();
StringBuffer sb2 = sb.append(true);
StringBuffer sb3 = sb.append("heima");
StringBuffer sb4 = sb.append(100);      
System.out.println(sb.toString());          //StringBuffer类中重写了toString方法,显示的是对象中的属性值
System.out.println(sb2.toString());
System.out.println(sb3.toString());
System.out.println(sb4.toString());

    }

}

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

  • A:StringBuffer的删除功能

    • public StringBuffer deleteCharAt(int index):
      • 删除指定位置的字符，并返回本身
    • public StringBuffer delete(int start,int end):
      • 删除从指定位置开始指定位置结束的内容，并返回本身

    public class Demo3_StringBuffer {

    public static void main(String[] args) {

    StringBuffer sb = new StringBuffer();
    //sb.deleteCharAt(5);                   //当缓冲区中这个索引上没有元素的时候就会报StringIndexOutOfBoundsException
    sb.append("heima");
    //sb.deleteCharAt(4);                   //根据索引删除掉索引位置上对应的字符
    //sb.delete(0, 2);                      //删除的时候是包含头,不包含尾
    //System.out.println(sb);
    //sb.delete(0, sb.length());                //清空缓冲区
    //System.out.println(sb);

    sb = new StringBuffer();                //不要用这种方式清空缓冲区,原来的会变成垃圾,浪费内存
    System.out.println(sb);
}

    }

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

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

public class Demo4_StringBufferMethod {

public static void main(String[] args) {

    StringBuffer sb = new StringBuffer("我爱总复习");
    //sb.replace(0, 3, "bai");                  //替换
    //System.out.println(sb);

    sb.reverse();
    System.out.println(sb);
}

}

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

  • A:StringBuffer的截取功能
    • public String substring(int start):
      • 从指定位置截取到末尾
    • public String substring(int start,int end):
      • 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

  • B:注意事项

    • 注意:返回值类型不再是StringBuffer本身

    public class Demo5_StringBufferMethod {

    public static void main(String[] args) {
    StringBuffer sb = new StringBuffer("woaiheima");
    //String str = sb.substring(4);
    //System.out.println(str);

    //System.out.println(sb);

    String str3 = sb.substring(4, 7);
    System.out.println(str3);
}

    }

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

  • A:String – StringBuffer
    • a:通过构造方法
    • b:通过append()方法

  • B:StringBuffer – String

    • a:通过构造方法
    • b:通过toString()方法
    • c:通过subString(0,length);

    public class Demo6_StringBuffer {

    public static void main(String[] args) {

    //demo1();
StringBuffer sb = new StringBuffer("heima");

String s1 = new String(sb);                     //通过构造将StringBuffer转换为String
System.out.println(s1);

String s2 = sb.toString();                      //通过toString方法将StringBuffer转换为String
System.out.println(s2);

String s3 = sb.substring(0, sb.length());       //通过截取子字符串将StringBuffer转换为String
System.out.println(s3);

    }

    private static void demo1() {

    StringBuffer sb1 = new StringBuffer("heima");           //通过构造方法将字符串转换为StringBuffer对象
System.out.println(sb1);

StringBuffer sb2 = new StringBuffer();
sb2.append("heima");                                    //通过append方法将字符串转换为StringBuffer对象
System.out.println(sb2);

    }

}

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

  • A:案例演示

    • 需求：把数组中的数据按照指定个格式拼接成一个字符串
    • 举例：
    int[] arr = {1,2,3};    
输出结果：
    "[1, 2, 3]"

用StringBuffer的功能实现

public class Test1 {

public static void main(String[] args) {
    int[] arr = {1,2,3};
    System.out.println(arrayToString(arr));
}

/*
 * 将数组转换为字符串
 * 1,返回值类型String
 * 2,参数列表int[]
 * 
 * arrayToString 将数组转换为字符串
 * array2String     2与to的发音一样就用2替换了to,后来演变成了一种书写习惯
 * dom4j  domForJ
 */

public static String arrayToString(int[] arr) {
    StringBuffer sb = new StringBuffer();               //创建字符串缓冲区对象
    sb.append("[");                                     //将[添加到缓冲区


    //{1,2,3}
    for (int i = 0; i < arr.length; i++) {              //遍历数组
        //sb.append(arr[i] + ", ");                     //这样做没有]
        if(i == arr.length - 1) {
            sb.append(arr[i]).append("]");              //[1, 2, 3]
        }else {
            sb.append(arr[i]).append(", ");             //[1, 2,
        }
    }
    return sb.toString();
}

}

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

  • A:案例演示
  • 需求：把字符串反转
    举例：键盘录入"abc"        
    输出结果："cba"

用StringBuffer的功能实现

public class Test2 {

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);                //创建键盘录入对象
    String line = sc.nextLine();                        //将键盘录入的字符串存储在line中

    /*StringBuffer sb = new StringBuffer(line);         //将字符串转换为StringBuffer对象
    sb.reverse();                                       //将缓冲区的内容反转

    System.out.println(sb.toString());*/

    System.out.println(revString(line));
}

/*
 * 将字符串反转
 * 1,返回值类型String
 * 2,参数列表String line
 */

public static String revString(String line) {
    StringBuffer sb = new StringBuffer(line);           //将字符串转换为StringBuffer对象
    sb.reverse();                                       //将缓冲区的内容反转

    return sb.toString();
}

}

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.11_常见对象(String和StringBuffer分别作为参数传递)

  • A:形式参数问题
    • String作为参数传递
    • StringBuffer作为参数传递
  • B:案例演示
    • String和StringBuffer分别作为参数传递问题

public class Demo7_StringBuffer {

/**
 * * A:形式参数问题
        * String作为参数传递
        * StringBuffer作为参数传递 
    * B:案例演示
        * String和StringBuffer分别作为参数传递问题
        * 
基本数据类型的值传递,不改变其值
引用数据类型的值传递,改变其值

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


    System.out.println("---------------------");
    StringBuffer sb = new StringBuffer();
    sb.append("heima");
    System.out.println(sb);
    change(sb);
    System.out.println(sb);
}

public static void change(StringBuffer sb) {
    sb.append("itcast");
}

public static void change(String s) {
    s += "itcast";
}

}

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

  • A:画图演示

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

  • A:画图演示

    • 需求：

      • 数组元素：{24, 69, 80, 57, 13}

      • 请对数组元素进行排序。

      • 选择排序

        • 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

13.13_常见对象(数组高级冒泡排序代码实现)

  • A:案例演示

    • 数组高级冒泡排序代码

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

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

    /**

      • A:案例演示
    • 数组高级冒泡排序代码
      */

    public static void main(String[] args) {

    int[] arr = {24, 69, 80, 57, 13};
bubbleSort(arr);
//selectSort(arr);
print(arr);

    }

        /*
 * 冒泡排序
 * 1,返回值类型,void
 * 2,参数列表,int[] arr
 * 
 *  第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比较4次
    第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比较3次
    第三次:arr[0]与arr[1],arr[1]与arr[2]比较2次
    第四次:arr[0]与arr[1]比较1次
 */

    public static void bubbleSort(int[] arr) {

    for (int i = 0; i < arr.length - 1; i++) {              //外循环只需要比较arr.length-1次就可以了
    for (int j = 0; j < arr.length - 1 - i; j++) {      //-1为了防止索引越界,-i为了提高效率
        if(arr[j] > arr[j+1]) {
            /*int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j+1] = temp;*/
            swap(arr,j,j+1);
        }
    }
}

    }

    /*
 * 打印数组
 * 1,返回值类型void
 * 2,参数列表int[]arr
 */

    public static void print(int[] arr) {

    for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}

    }

    /*
 * 选择排序
 * 1,返回值类型void
 * 2,参数列表int[] arr
 * 
 *  第一次:arr[0]分别与arr[1-4]比较,比较4次
    第二次:arr[1]分别与arr[2-4]比较,比较3次
    第三次:arr[2]分别与arr[3-4]比较,比较2次
    第四次:arr[3]与arr[4]比较,比较1次
 */

    public static void selectSort(int[] arr) {

    for (int i = 0; i < arr.length - 1; i++) {              //只需要比较arr.length-1次
    for (int j = i + 1; j < arr.length; j++) {
        if(arr[i] > arr[j]) {
            /*int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;*/
            swap(arr,i,j);
        }
    }
}

    }

    /*
 * 换位操作
 * 1,返回值类型,void
 * 2,参数列表int[] arr.int i,int j
 * 
 * 如果某个方法,只针对本类使用,不想让其他类使用就可以定义成私有的
 */

    private static void swap(int[] arr,int i,int j) {

    int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;

    }

}

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

  • A:画图演示
    • 二分查找
    • 前提：数组元素有序

13.17_常见对象(数组高级二分查找代码实现及注意事项)

  • A:案例演示
    • 数组高级二分查找代码
  • B:注意事项
    • 如果数组无序，就不能使用二分查找。
      • 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

public class Demo2_Array {

public static void main(String[] args) {
    int[] arr = {11,22,33,44,55,66,77};
    System.out.println(getIndex(arr, 22));
    System.out.println(getIndex(arr, 66));
    System.out.println(getIndex(arr, 88));
}

/*
 * 二分查找
 * 1,返回值类型,int
 * 2,参数列表int[] arr,int value
 */

public static int getIndex(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 = mid + 1;                      //最小的索引改变
        }else if (arr[mid] > value){            //当中间值大于了要找的值
            max = mid - 1;                      //最大的索引改变
        }

        mid = (min + max) / 2;                  //无论最大还是最小改变,中间索引都会随之改变

        if(min > max) {                         //如果最小索引大于了最大索引,就没有查找的可能性了
            return -1;                          //返回-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)

    public class Demo3_Arrays {

    /**

    public static String toString(int[] a)

    public static void sort(int[] a)

public static int binarySearch(int[] a,int key)

    public static String toString(int[] a) {

            if (a == null)                              //如果传入的数组是null
            return "null";                          //返回null
        int iMax = a.length - 1;                    //iMax最大索引
        if (iMax == -1)                             //如果数组中没有元素
            return "[]";                            //返回[]

        StringBuilder b = new StringBuilder();      //线程不安全,效率高
        b.append('[');                              //将[添加到字符串缓冲区中
        for (int i = 0; ; i++) {                    //遍历数组,判断语句没有写默认是true
            b.append(a[i]);                         //把第一个元素添加进字符串缓冲区
            if (i == iMax)                          //如果索引等于了最大索引值
                return b.append(']').toString();    //将]添加到字符串缓冲区,在转换成字符串并返回
            b.append(", ");                         //如果不等于最大索引就将, 添加到缓冲区
        }
    }

 private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                             int key) {
        int low = fromIndex;                //最小索引0
        int high = toIndex - 1;             //最大索引数组长度-1

        while (low <= high) {               //最小索引小于等于最大索引可以循环判断
            int mid = (low + high) >>> 1;   //求出中间索引值,(最小+最大)/2
            int midVal = a[mid];            //通过中间索引获取中间值

            if (midVal < key)               //中间索引对应的值小于查找的值
                low = mid + 1;              //最小索引变化
            else if (midVal > key)          //中间索引对应的值大于查找的值
                high = mid - 1;             //最大索引变化
            else
                return mid; // key found    //找到了
        }
        return -(low + 1);  // key not found.//-插入点 - 1
    }

    */
    public static void main(String[] args) {

    int[] arr = {33,22,11,44,66,55};
System.out.println(Arrays.toString(arr));           //数组转字符串

Arrays.sort(arr);                                   //排序
System.out.println(Arrays.toString(arr));

int[] arr2 = {11,22,33,44,55,66};
System.out.println(Arrays.binarySearch(arr2, 22));
System.out.println(Arrays.binarySearch(arr2, 66));
System.out.println(Arrays.binarySearch(arr2, 9));   //-插入点-1

    }

}

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

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

  • byte Byte
    short Short
    int Integer
    long Long
    float Float
    double Double
    char Character
    boolean Boolean

public class Demo1_Integer {

public static void main(String[] args) {
    System.out.println(Integer.toBinaryString(60));
    System.out.println(Integer.toOctalString(60));
    System.out.println(Integer.toHexString(60));
}

}

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

  • A:Integer类概述

    • 通过JDK提供的API，查看Integer类的说明

    • Integer 类在对象中包装了一个基本类型 int 的值,

    • 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
    • 还提供了处理 int 类型时非常有用的其他一些常量和方法
  • B:构造方法
    • public Integer(int value)
    • public Integer(String s)
  • C:案例演示
    • 使用构造方法创建对象

public class Demo2_Integer {

public static void main(String[] args) {
    System.out.println(Integer.MAX_VALUE);
    System.out.println(Integer.MIN_VALUE);

    Integer i1 = new Integer(100);
    System.out.println(i1);

    //Integer i2 = new Integer("abc");          //java.lang.NumberFormatException数字格式异常
    //System.out.println(i2);                       //因为abc不是数字字符串,所以转换会报错

    Integer i3 = new Integer("100");
    System.out.println(i3);
}

}

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

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

public class Demo3_Integer {

public static void main(String[] args) {

    //demo1();
    String s1 = "true";
    boolean b = Boolean.parseBoolean(s1);
    System.out.println(b);

    //String s2 = "abc";
    //char c = Character.p      //char的包装类Character中没有pareseXxx的方法
                                //字符串到字符的转换通过toCharArray()就可以把字符串转换为字符数组
}

private static void demo1() {
    //int ----> String int转换成String
    int i = 100;
    String s1 = i + "";                     //推荐用
    String s2 = String.valueOf(i);          //推荐用

    Integer i2 = new Integer(i);
    String s3 = i2.toString();

    String s4 = Integer.toString(i);
    System.out.println(s1);

    //String----> int String 转换int
    String s = "200";
    Integer i3 = new Integer(s);
    int i4 = i3.intValue();                 //将Integer转换成了int数

    int i5 = Integer.parseInt(s);           //将String转换为int,推荐用这种
}

}

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

  • A:JDK5的新特性
    • 自动装箱：把基本类型转换为包装类类型
    • 自动拆箱：把包装类类型转换为基本类型

  • B:案例演示

    • JDK5的新特性自动装箱和拆箱

    • Integer ii = 100;

    • ii += 200;

  • C:注意事项

    • 在使用时，Integer x = null;代码就会出现NullPointerException。

    • 建议先判断是否为null，然后再使用。
      public class Demo4_JDK5 {

      public static void main(String[] args) {

      // int x = 100;

      // Integer i1 = new Integer(x); //将基本数据类型包装成对象,装箱
      //
      // int y = i1.intValue(); //将对象转换为基本数据类型,拆箱

      Integer i2 = 100;                       //自动装箱,把基本数据类型转换成对象
int z = i2 + 200;                       //自动拆箱,把对象转换为基本数据类型
System.out.println(z);

Integer i3 = null;
int a = i3 + 100;                       //底层用i3调用intValue,但是i3是null,null调用方法就会出现
System.out.println(a);                  //空指针异常java.lang.NullPointerException

      }

    }

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

  • A:Integer的面试题
  • 看程序写结果

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

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

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

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

public class Demo5_Integer {

public static void main(String[] args) {
    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));          //true
    System.out.println("-----------");

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

    Integer i7 = 128;
    Integer i8 = 128;
    System.out.println(i7 == i8);
    System.out.println(i7.equals(i8));          //true

    /*
     * -128到127是byte的取值范围,如果在这个取值范围内,自动装箱就不会新创建对象,而是从常量池中获取
     * 如果超过了byte取值范围就会再新创建对象
     * 
     * public static Integer valueOf(int i) {
            assert IntegerCache.high >= 127;
            if (i >= IntegerCache.low && i <= IntegerCache.high)            //i>= -128 && i <= 127
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
     */
}

}

今天就更新在这里!今天的东西挺多的大家努力学习

First 007
关注
专栏目录
StringBuffer类
m0_49941256的博客
05-12 518
StringBuffer类的概述 StringBuffer类概述 我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题 线程安全的可变字符序列 StringBuffer类的构造方法 StringBuffer的构造方法： public StringBuffer(): 无参构造方法 public StringBuffer(int capacity): 指定容量的字符串缓冲区对象 public StringBuffe
java stringbuffer数组_JavaSE知识-13(StringBuffer&数组排序)
weixin_33331639的博客
02-24 445
StringBuffer类的概述通过JDK提供的API, 查看StringBuffer类的说明线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。StringBuffer类的构造方法每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的...
java stringbuffer数组_Java学习日记-4 StringBuffer类和数组
weixin_42172572的博客
02-24 385
标签：一、StringBuffer类StringBuffer是一个可变字符序列。1.1 构造函数StringBuffer()　　构造一个不带字符的字符缓冲区，初始容量为16个字符。StringBuffer(int capacity)　　构造一个具有指定初始容量的字符缓冲区StringBuffer(String str)　　构造一个内容为指定字符串的字符缓冲区，初始容量为字符串容量加上161.2 S...
java stringbuffer数组_Java中字符数组、String类、StringBuffer三者之间相互转换
weixin_29958123的博客
02-16 541
一、StringBuffer与String的相互转换1、将StringBuffer转换成StringStringBuffer类成员toString函数可将其转换成String类型。StringBuffer buffer = newStringBuffer(“abcd”);String str = buffer.toString();通过String类中的构造将一个StringBuffer类转换为S...
StringBuffer类和数组
taisang89的博客
11-25 839
一、StringBuffer类 　　StringBuffer是一个可变字符序列。   1.1 构造函数 　　StringBuffer()　　构造一个不带字符的字符缓冲区，初始容量为16个字符。 　　StringBuffer(int capacity)　　构造一个具有指定初始容量的字符缓冲区 　　StringBuffer(String str)　　构造一个内容为指定字符串的字符缓冲区，初始
Java学习day01-day15学习资料
最新发布
04-05
7. **day10**: 字符串（String）是Java中非常重要的一部分，这部分可能讲解了String类的特性，如不可变性、常用的方法如concat(), substring(), equals()等，以及如何使用StringBuilder或StringBuffer进行字符串拼接...
Java_day04上课资料.zip
03-24
【Java_day04上课资料.zip】是一个包含Java学习资源的压缩包，可能涵盖了第四天Java课程的全部内容。从这个标题我们可以推测，这份资料可能是针对初学者或正在学习Java编程的学员，旨在帮助他们深入理解Java语言的...
Java_day03上课资料.zip
03-24
【Java_day03上课资料.zip】是一个包含Java学习资源的压缩包，主要针对初学者或有一定基础的学习者，旨在深入理解和掌握Java编程语言的核心概念和技术。这个压缩包可能包括课件、代码示例、练习题等内容，以帮助学生...
【Java】day13--模板设计模式、Object类、String类、StringBuffer类部分知识点总结
Greenary的博客
03-06 382
(一)模板设计模式 模板设计模式：在解决某类问题的时候，有些步骤固定，有些步骤不固定，可以用模板设计模式 模板设计模式的步骤： 1.先写出解决该类问题其中的一个解决方法。 2.分析代码，把会发生变化的代码抽取出来独立成一个方法。再把该方法描述成一个抽象的方法。 3.如果需要使用模板类，只需要继承即可使用 需求：编写一个计算代码运行时间的模板。 代码： ab...
Java基础学习Day09--字符串
qq_45732338的博客
06-23 540
Java基础学习Day09
java stringbuffer数组_一、javaSE （十三）StringBuffer类、数组高级以及 Arrays类、Integer类、Character类...
weixin_29159613的博客
02-24 175
1: StringBuffer(掌握)(1)用字符串做拼接,比较耗时并且也耗内存,而这种拼接操作又是比较常见的,为了解决这个问题,Java就提供了一个字符串缓冲区类。 StringBuffer供我们使用(2) StringBuffer的构造方法A: StringBuffer ()B: StringBuffer (int size)C: StringBuffer (String str)(3) St...
java stringbuffer数组_Java学习笔记（五）：StringBuffer的方法
weixin_28677451的博客
02-24 406
磨砺是成功路上的垫脚石，为梦想坚持到底，哪怕遍地荆棘也要勇敢前行。记录java学习路上的点滴技术，不仅会让自己的学习之路更加轻松一些，还有另一个作用，等到自己回过头来翻看这些记录的时候，想想自己当初居然能够连载这么多篇，成就感满满(哈哈)！今天的java学习笔记是：StringBuffer的方法1.增加StringBuffer str =new StringBuffer("hello");str1...
定义StringBuffer数组后,勿忘创建StringBuffer对象
大伟
06-22 996
如下程序：public class ThisHappens {    public static void main(String[] args) {        StringBuffer[] stringBuffers = new StringBuffer[10];        for (int i = 0; i &lt; stringBuffers.length; ...
String类，StringBuffer类转字符数组
baifei7979的博客
04-13 273
String不可变类型和StringBuffer可变类型 String类和StringBuffer类都是字符串表示类，区别在于String对象引用变量是不可变的，而StringBuffer类对象引用变量是可变的。 我当时学的时候也会很不理解这个可变不可变的区别，后面看了一篇博客才懂了这个意思（https://www.cnblogs.com/yumiaoxia/p/9010721.ht...
JAVA基础之StringBuffer类与数组常见操作
weixin_42478671的博客
05-07 1183
1. StringBuffer概念与构造方法 1.1 概念 如果我们要对字符串进行拼接操作，每次拼接都会重新构建一个String对象，会浪费我们很多时间且这样还会浪费空间。 而StringBuffer则解决了这个问题，它包含多个字符的字符串数据，对象是可以扩充和修改的。 1.1.1 StringBuffer与String的区别 String的特点是一旦赋值，便不能更改其指向的字符对象，如...
Java中的StringBuffer和数组Arrays以及常用类型的包装类
我与大象的故事
08-16 400
1:StringBuffer(掌握)     (1)用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了一个字符串缓冲区类。StringBuffer供我们使用。     (2)StringBuffer的构造方法         A:StringBuffer()         B:StringBuffer(int size)       
stringbuffer,数组排序
qq_46466568的博客
07-30 839
stringbuffer 可以解决拼串操作，也叫做线程安全的可变序列。 stringbuffer的构造方法 StringBuffer的构造方法： public StringBuffer(): 无参构造方法 public StringBuffer(int capacity): 指定容量的字符串缓冲区对象 public StringBuffer(String str): 指定字符串内容的字符串缓冲区对象 StringBuffer的方法： public int capacity()：返回当前容量。 理论值
StringBuffer--数组常见操作--基本数据类型包装类
zpj890512的博客
10-25 344
一、StringBuffer StringBuffer类概述 我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。 而StringBuffer就可以解决这个问题 线程安全的可变字符序列 StringBuffer和String的区别： StringBuffer就像一个容器，用于操作字符串 StringBuffer 你可以理解为一个长度可变的字符串容器 Str...
String，String Buffer，数组，对象和类的简单总结
JDKANDER的博客
04-06 808
首先是String和String Buffer这两个都不属于八种基本数据类型，属于类类型，而在工作当中由于前者使用的次数较为平凡，所以在定义过程中使其能像基本数据那样的格式去定义，不用通过new语句来进行定义，而其的使用中，常常会有一些重要的语句来更好地让我们了解这段字符串，比如index of()，endwith()，length()等等，字符串在使用中必须用英文双引号引起来，而对比String
1、实验描述 本实验主要是通过以字节读取文件的方式，读取并打印本地文本数据。 2、推荐步骤 2-1. 新建项目工程，工程名为CORE_C09_001： 2-1.1. 在当前工程根目录下创建一个文本文件：myjava.txt 2-1.2. 在文本文件中写a~z的26个英文小写字母并保存 2-1.3. 创建java类-Fileoutput。 2-2. 创建读取文件内容的方法-readFile，入参为文件路径，返回值类型为String。 2-3. readFile方法中的变量初始化： 2-3.1. 创建StringBuffer类型变量实例，用于存放多次读取到的文本数据。 2-3.2. 创建byte[]类型的变量，长度为2048，用于存储一次读取到的字节数据。 2-3.3. 创建int类型的变量count，用于记录一次读取到的字节数。 2-4. readFile方法中循环读取文件数据： 2-4.1. 用入参做参数，生成FileInputStream类型的实例。 2-4.2. 创建while循环，循环读取数据： 1） 循环条件：执行FileInputStream对象的read函数，把读到的数据存到byte数组中， 把read函数的返回值存放到count变量中，并且count不等于-1。 2） 循环内容：将读取到的数据转换并添加到StringBuffer中。 2-4.3. 关闭文件读取流-FileInputStream对象。 2-5. 抓取IO异常： 2-5.1. try-catch语句抓取2-4中抛出的IOException。 2-6. 循环结束后，返回StringBuffer中的文本数据。 3、验证与测试： 3-1. 程序测试： 3-1.1. 创建程序入口函数-main 3-1.2. 调用readFile方法，读取当前项目工程下的myjava.txt文件内容并输出到控制台 1） 文件路径：myjava.txt 3-1.3. 运行该项目，观察控制台能否显示文件中的内容。
06-09
好的，以下是实现以上要求的Java代码： ```java import java.io.FileInputStream; import java.io.IOException; public class Fileoutput { public static void main(String[] args) { String filePath = "myjava.txt"; String fileContent = readFile(filePath); System.out.println(fileContent); } public static String readFile(String filePath) { StringBuffer stringBuffer = new StringBuffer(); byte[] buffer = new byte[2048]; int count; try { FileInputStream fileInputStream = new FileInputStream(filePath); while ((count = fileInputStream.read(buffer)) != -1) { String text = new String(buffer, 0, count); stringBuffer.append(text); } fileInputStream.close(); } catch (IOException e) { e.printStackTrace(); } return stringBuffer.toString(); } } ``` 在运行该程序之前，需要确保在当前工程根目录下有名为`myjava.txt`的文本文件，并且其中已经写入了26个英文小写字母。运行程序后，控制台将会输出文本文件中的内容。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值