黑马程序员_java语言_StringBuffer,Array以及Integer分析

来源：互联网发布：windows上dmg转换cdr 编辑：程序博客网时间：2024/05/21 17:20

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

###06.01_常见对象(StringBuffer类的概述)
* A:StringBuffer类概述
* 通过JDK提供的API，我们可以知道它是一种线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

    * B:简述安全问题
    * 线程安全效率低
* C:StringBuffer和String的区别
    * String是一个不可变的字符序列

     注意：字符串的内容不能改变，但是，对应地址可以改变
*             长度与内容都是固定的
    * StringBuffer是一个可变的字符序列线程安全的类 -- 效率低 -- 安全
*                      长度与内容都可以发生改变

###06.02_常见对象(StringBuffer类的构造方法)
* A:StringBuffer的构造方法：
    * public StringBuffer():无参构造方法
    * public StringBuffer(int capacity):指定容量的字符串缓冲区对象
    * public StringBuffer(String str):指定字符串内容的字符串缓冲区对象

对于以上构造方法我们可以通过下面的代码进行实现：

<span style="font-size:14px;">public class StringBufferDemo {public static void main(String[] args) {//public StringBuffer()StringBuffer sb = new StringBuffer();// 构造一个其中不带字符的字符串缓冲区System.out.println("capacity:" + sb.capacity());System.out.println("length:" + sb.length());//public StringBuffer(int capacity)StringBuffer buffer = new StringBuffer(100);  // 构造一个不带字符，但具有指定初始容量的字符串缓冲区。System.out.println("capacity:" + buffer.capacity());System.out.println("length:" + buffer.length());//public StringBuffer(String str)StringBuffer buffer2 = new StringBuffer("java");   //构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容System.out.println("capacity:" + buffer2.capacity());System.out.println("length:" + buffer2.length());}}</span>

* B:StringBuffer的方法：
* public int capacity()：返回当前容量。

<span style="font-size:14px;">  StringBuffer sb=new StringBuffer("java");  int len=sb.capacity();  System.out.println(len);</span>

* public int length():返回长度（字符数）。

<span style="font-size:14px;">  StringBuffer sb=new StringBuffer("java");   int len=sb.length();  System.out.println(len);</span>

###06.03_常见对象(StringBuffer的添加功能)
* A:StringBuffer的添加功能
    * public StringBuffer append(String str):
        * 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
    * public StringBuffer insert(int offset,String str):
        * 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

对于append（）和insert（）方法的案例演示：

<span style="font-size:14px;">public class StringBufferDemo {public static void main(String[] args) {//创建对象StringBuffer sb = new StringBuffer();//追加数据                sb.append(true);sb.append(3.14);sb.append("HelloWorld");//添加数据public StringBuffer insert(int offset, String str)sb.insert(4, "JAVA");//显示//System.out.println(sb.toString());System.out.println(sb);//System.out.println(sb2);//System.out.println(sb == sb2 );}}</span>

###06.04_常见对象(StringBuffer的删除功能)
* A:StringBuffer的删除功能
    * public StringBuffer deleteCharAt(int index):
        * 删除指定位置的字符，并返回本身
    * public StringBuffer delete(int start,int end):
        * 删除从指定位置开始指定位置结束的内容，并返回本身

案例掩饰：

<span style="font-size:14px;">StringBuffer buffer = new StringBuffer();//添加数据buffer.append("Java").append("Hello");//链式编程//buffer.append("Hello");//buffer.append("World");//buffer.deleteCharAt(4);//System.out.println(buffer);//public StringBuffer delete(int start, int end)//buffer.delete(0, 3);buffer.delete(0, 4);//显示//buffer.deleteCharAt(0);System.out.println(buffer);</span>

###06.05_常见对象(StringBuffer的替换和反转功能)
* A:StringBuffer的替换功能
    * public StringBuffer replace(int start,int end,String str):
        * 从start开始到end用str替换
* B:StringBuffer的反转功能
    * public StringBuffer reverse():
        * 字符串反转

案例演示：

<span style="font-size:14px;">StringBuffer buffer = new StringBuffer();buffer.append("Hello");buffer.append("Java");//buffer.append(123);//反转功能//buffer.reverse();//替换功能//public StringBuffer replace(int start, int end, String str)//buffer.replace(5, 9, "World");//buffer.replace(5, buffer.length(), "World");System.out.println(buffer);</span>

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

案例演示：

<span style="font-size:14px;">sb.append(1234567890);//public String substring(int start)//String result = sb.substring(5);  67890//public String substring(int start,int end)//678String result = sb.substring(5, 8);System.out.println(result);System.out.println(sb);</span>

###06.07_常见对象(StringBuffer和String的相互转换)
* A:String -- StringBuffer
* a:通过构造方法
* b:通过append()方法

<span style="font-size:14px;">//String 转换成  StringBuffer  StringBuffer sb = new StringBuffer();  sb.append("Java");  System.out.println(sb);</span>

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

对于以上三种变化形式的代码体现：

<span style="font-size:14px;">//StringBuffer 转换成 String//方式1//StringBuffer sb = new StringBuffer("Hello");//通过 toString()//System.out.println(sb.toString());//方式2//通过String类的构造方法 //StringBuffer sb = new StringBuffer("Hello");//String str = new String(sb);//System.out.println(str);//方式3//3: 通过String类的方法  public static String valueOf(Object obj)StringBuffer sb = new StringBuffer("Hello");String result = String.valueOf(sb);System.out.println(result);</span>

###06.08_常见对象(把数组转成字符串)
* A:案例演示
* 需求：把数组中的数据按照指定个格式拼接成一个字符串

<span style="font-size:14px;">public class Test2 {public static void main(String[] args) {//1: 定义int类型的数组int[] arr = {1,2,3};//2：  创建一个StringBuffer对象，用来拼接字符 StringBuffer buffer = new StringBuffer("[");//3: 遍历数组，得到每一个元素for (int i=0; i<arr.length; i++ ) {//arr[i];//4: 拼接操作if (i == arr.length - 1) {buffer.append(arr[i]).append("]");} else {buffer.append(arr[i]).append(", ");}}//[1, 2, 3]//5: 把StringBuffer 转换为 字符串StringSystem.out.println(buffer.toString());}}</span>

###06.09_常见对象(字符串反转)
* A:案例演示
*

需求：把字符串反转

<span style="font-size:14px;">//创建字符串String str = new String("12345");//反转StringBuffer sb = new StringBuffer(str);sb.reverse();//获取反转后的字符串System.out.println(sb.toString());</span>

<span style="font-size:14px;"></span>

###06.10_常见对象(StringBuffer和StringBuilder的区别)
* A:StringBuilder的概述
    * 通过查看API了解到它是个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer 要快。
* B:面试题
    * String,StringBuffer,StringBuilder的区别
    * StringBuffer和StringBuilder的区别：
    * StringBuffer是jdk1.0版本的,是线程安全的,效率低
    * StringBuilder是jdk1.5版本的,是线程不安全的,效率高

    * String和StringBuffer,StringBuilder的区别
    * String是一个不可变的字符序列
    * StringBuffer,StringBuilder是可变的字符序列

###06.11_常见对象(String和StringBuffer分别作为参数传递)
* A:形式参数问题
    * String作为参数传递
    * StringBuffer作为参数传递
* B:案例演示
    * String和StringBuffer分别作为参数传递问题

<span style="font-size:14px;">String str = "hello";change(str);System.out.println(str);StringBuffer sb = new StringBuffer("Java");change(sb);System.out.println(sb);}//StringBuffer作为参数传递public static void change(StringBuffer sb) {sb.append("Haha");}//String作为参数传递public static void change(String str) {str = "world";}</span>

从以上代码中我们可以得出结果：
String作为参数传递
    : 常量，String类型作为参数的变化，与基本数据类型一致
               形式参数的改变对实际参数没有影响

StringBuffer作为参数传递
      : 形式参数的改变对实际参数有影响

###06.12_常见对象(数组高级冒泡排序原理图解)
* A:画图演示
*   需求：
            数组元素：{24, 69, 80, 57, 13}
            请对数组元素进行排序。

      从以上图例中我们可以得到冒泡排序思想：
                相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

代码体现：

<span style="font-size:14px;">int[] arr = {3,9,5,7,1};//查看下排序前的结果,遍历printArray(arr);//排序sort(arr);</span>

<span style="font-size:14px;">printArray(arr);  //查看下排序后的结果,遍历}//冒泡排序public static void sort(int[] arr) {//外层循环  控制比较的次数for (int i = 0; i < arr.length-1; i++) {//内层循环， 用来控制比较的元素//j < arr.length -1 , 避免角标越界//j < arr.length-1-i, 避免重复比较for (int j = 0; j < arr.length-1-i; j++) {if (arr[j]> arr[j+1]) {int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}//完成数组的遍历   [1,2,3,4,5]public static void printArray(int[] arr){//定义字符串缓冲区对象StringBuilder sb = new StringBuilder("[");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.toString());</span>

<span style="font-size:14px;"></span>

###06.13_常见对象(数组高级选择排序原理图解)
* A:画图演示
    * 需求：
        * 数组元素：{24, 69, 80, 57, 13}
        * 请对数组元素进行排序。

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

代码实现：

<span style="font-size:14px;">int[] arr = {3,9,5,7,1};//查看下排序前的结果,遍历printArray(arr);//排序sort(arr);//查看下排序后的结果,遍历printArray(arr);}//选择排序public static void sort(int[] arr) {//比较次数的控制for (int i = 0; i < arr.length-1; i++) {//控制参与比较的元素// int j = i+1; 避免与自身进行比较for (int j = i+1; j < arr.length; j++) {//arr[i] 与 arr[j]if (arr[i] > arr[j]) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}}}</span>

<span style="font-size:14px;"></span>

###06.14_常见对象(数组高级二分查找原理图解)
* A:画图演示
    * 二分查找
    * 前提：数组元素有序

###06.15_常见对象(数组高级二分查找代码实现及注意事项)
* A:案例演示
    * 数组高级二分查找代码
* B:注意事项
    * 如果数组无序，就不能使用二分查找。
        * 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

###06.16_常见对象(Arrays类的概述和方法使用)
* A:Arrays类概述
    * 针对数组进行操作的工具类。
    * 提供了排序，查找等功能。
* B:成员方法
    * public static String toString(int[] a)
    * public static void sort(int[] a)
    * public static int binarySearch(int[] a,int key)
我们用代码实现：

<span style="font-size:14px;">                int[] arr = {1,3,9,5,7};String result = Arrays.toString(arr);System.out.println(result);//排序Arrays.sort(arr);//[1, 3, 5, 7, 9]System.out.println( Arrays.toString(arr) );//[1, 3, 5, 7, 9]int index = Arrays.binarySearch(arr, 5);System.out.println(index);//在数组中 不存在的数据index = Arrays.binarySearch(arr, 2);System.out.println(index);</span>

###06.17_常见对象(基本类型包装类的概述)
* A:为什么会有基本类型包装类
    * 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
* B:常用操作
    * 常用的操作之一：用于基本数据类型与字符串之间的转换。
* C:基本类型和包装类的对应
*
        byte             Byte
        short            Short
        int                Integer
        long            Long
        float            Float
        double          Double
        char            Character
        boolean            Boolean

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

<span style="font-size:14px;">       //public Integer(int value)Integer in = new Integer(123);//构造一个新分配的 Integer 对象，它表示所指示的 int 值           </span>

<span style="font-size:14px;">System.out.println(in);//public Integer(String s)Integer in2 = new Integer("12345");//构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。System.out.println(in2);</span>

###06.19_常见对象(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类的静态方法)

<span style="font-size:14px;">                //把10进制 转换成指定的进制//System.out.println(  Integer.toString(60, 16) );//System.out.println(  Integer.toString(60, 32) );//System.out.println(  Integer.toString(60, 7) );//----------------------------//其他进制 转换成  10进制System.out.println( Integer.parseInt("3c", 16) );System.out.println( Integer.parseInt("111100", 2) );System.out.println( Integer.parseInt("74", 8) );</span>

* B:String -- int
* a:String -- Integer -- int

* public static int parseInt(String s)

<span style="font-size:14px;">//1: String --> Integer --> intInteger in = new Integer("123");int num = in.intValue();System.out.println(num);        //public static int parseInt(String s)int num2 = Integer.parseInt("12345");System.out.println(num2);</span>

首先从String转成成Integer，然后再通过Integer转换成int

###06.20_常见对象(JDK5的新特性自动装箱和拆箱)
* A:JDK5的新特性
    * 自动装箱：把基本类型转换为包装类类型
    * 自动拆箱：把包装类类型转换为基本类型
* B:案例演示
    * JDK5的新特性自动装箱和拆箱

<span style="font-size:14px;">    * Integer ii = 100;    * ii += 200;</span>

自动将Integer转换成int类型，这种转换就属于自动拆箱


   * C:注意事项
    * 在使用时，Integer  x = null;代码就会出现NullPointerException。
    * 建议先判断是否为null，然后再使用。

0 0