java基础复习(十二)

java基础第十二天

StringBuffer类

线程安全,可变的字符序列。

线程安全效率比较低,线程不安全一般效率会比较高。

看一个类的时候,先去看一个类的构造方法。

StringBuffer线程安全

StringBuilder线程不安全,不执行同步,效率会比较高。

StringBuffer的构造方法:

  • StringBuffer() 构造一个没有字符的字符串缓冲区,初始容量为16个字符
  • StringBuffer(CharSequence seq)构造一个包含于指定的相同字符串缓冲区CharSequence
  • StringBuffer(int capacity)构造一个没有字符的字符串缓冲区和指定的初始容量
  • StringBuffer(String str)构造一个初始化为指定字符串内容的字符串缓冲区

have a try 构造方法

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

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

StringBuffer sb3 = new StringBuffer("heima");
System.out.println(sb3.length());//5 实际字符的个数
System.out.println(sb.capacity());//21 实际字符的个数+length

append()方法 末尾插入

StringBuffer sb = new StringBuffer();
System.out.println(sb.toString);
System.out.println(sb);//意味着StringBuffer重写了toString方法
StringBuffer sb2 = sb.append(true); 
System.out.println(sb2);//true

StringBuffer sb3 = sb.append("heima");
System.out.println(sb3);//trueheima

StringBuffer sb4 = sb.append(100);

System.out.println(sb2);//trueheima100
System.out.println(sb3);//trueheima100
System.out.println(sb4);//trueheima100
//可以吧任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身。
//在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
//StringBuffer是字符串缓冲区,当new的时候是在堆内存创建了一个对象,底层是一个长度为16的字符数组。当调用添加的方法时。不会再重新创建对象,在不断向原缓冲区添加字符。

insert()方法 在指定位置添加元素,如果没有指定位置的索引,就会报索引越界异常。

StringBuffer sb =new StringBuffer("1234");
sb.insert(3,"heima");
System.out.println(sb);//123heima4

deleteCharAt();

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

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

replace和reverse

StringBuffer sb = new StringBuffer("heima");
sb.replace(0,3,"bai"); //替换
System.out.println(sb);

sb.reverse();
System.out.pritnln(sb);
/*StringBuffer的截取功能*/
StringBuffer sb = new StringBuffer("woaiheima");
Stirng str = sb.substring(4);
System.out.println(str);//heima
System.out.println(sb);//woaiheima

String与StringBuffer的相互转换

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


String s1 = new String(sb);//通过构造将StringBuffer转换为String
String s2 = new sb.toString();//通过toString方法【常用】
String s3 = new sb.substring(0,sb.length());//substring

练习:把数组转换程字符串

int[] arr = {1,2,3};
将数组转换成字符串
1.返回值类型String
2.参数列表int[]

4:For 2:to

1554796246558

练习:把字符串反转

1554796552207

StringBuilder类

方法和StringBuffer基本上是一样的。

StringBuffer和StringBuilder的区别:

StringBuffer jdk1.0 是线程安全的,效率低

StringBuilder jdk1.5 是线程不安全。效率高。

String和StringBuffer,StringBuilder的区别

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

StringBuffer和StringBuilder是可变的字符序列

基本数据类型的值传递,不改变其值

和引用数据类型的值传递,改变其值。

String和StringBuffer作为参数的时候会不会改变

String类虽然是引用数据类型,但是他当做参数传递时和基本数据类型是一样的。String类一旦初始化就不会被改变。【举一个弹栈的例子就可以】

StringBuffer 两个引用指向同一个对象

数组高级冒泡排序【图解】

int arr = {24,69,80,57,13};

冒泡排序:轻的上浮,沉的下降。

两个相邻位置比较,如果前面的元素比后面的元素大就换位置。

规律:

第一次,arr[0]与arr[1],arr[1]与arr[2]...比较四次

第二次,arr[0]....比较三次

第三次,arr[0]....比较两次

第四次,arr[0]...比较一次

和倒三角很相似。

使用for的嵌套循环,外层决定比较几次,内层进行值得比较

class DemoBubbleSort{
    public static void main(String[] args){
        int[] arr = {10,50,100,15,30,60,44};
        bubbleSort(arr);
        print(arr);
    }

    //入参:int arr
    //返回值类型:void
    //冒泡排序:两个相邻位置比较,如果前面的元素比后面的元素,
    public static void bubbleSort(int arr[]){
        for(int i = 0;i < 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;
                }
            }
        }

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

}

数组高级选择排序

选择排序就是用一个索引位置上的元素,依次与其他索引位置上的元素比较,小的在前面,大的在后面。

最小值出现,最小值放第一个位置,然后从第二个值开始比较。

分析:

第一次:arr[0]分别于arr[1-4]比较

第二次:arr[1]分别于arr[2-4]比较

第三次:arr[2]分别与arr[3-4]比较

第四次:arr[3]与arr[4]比较

class DemoSelectSort{
    public static void main(String[] args){
        int[] arr = {10,50,100,15,30,60,44};
        selectSort(arr);
        print(arr);
    }
    public static void selectSort(int arr[]){
        for(int i = 0 ;i < arr.length -1 ;i++){
            for(int j = i+1 ;j < arr.length -1;j++){
                if(arr[i] > arr[j]){
                    int temp;
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
    public static void print(int arr[]){
        for(int i = 0;i < arr.length-1;i++){
            System.out.print(arr[i]+"  ");
        }
    }
}

我觉得我有点怕写算法是不会分析这个题目,所以,重点应该是分析整个题目。思路优先。

还有啥排序之类的,我一听名字可能不知道怎么样的,不理解他的意思。

【面试的时候用】

数组高级二分查找原理

猜数字

通过数值找索引

二分查找:

  • 前提:数组元素有序
  • int min = 0;
  • int max =arr.length -1;
  • int mid = (min + max)/2;

1554802060408

public static void main(String[] args){
    int[] arr = {11,22,33,44,55,66,77}
}

/*
二分查找
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;
        }
    }
    return mid;
}

Arrays类的概述和方法使用

java.util.Arrays

数组工具类:

public static String toString(int arr[]);//数组转字符串

public static void sort(int arr[]);//排序-----使用的是快速排序,效率比较高

public static int binarySearch(int[] arr,int key);// 有时候会出现负数【查看文档】 负的插入点-1 -1怕插入点为0

为什么会有基本类型包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。

常用操作:

常用的操作之一:用于基本数据类型与字符串之间的转换。

基本类型与包装类:8种

基本类包装类
byteByte
intInteger
shortShort
charCharacter

Interger

1.构造方法

2.方法、行为

3.常量、属性

String类型与Integer类型的相互转化

//int转化为String

int i=100;
String s1 = i + "";//推荐 写法比较简单
String s2 = String.valueOf(i);

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

String s4 = Interger.toString(i);

//String转int
String s = "200";
Integer i3 = new Integer(s);
int i4 =i3.intValue();

int i5 = Interger.parseInt(s);//将String转换为int,推荐用这种
//基本数据类型包装类有八种,其中七种都有parseXXX的方法,可以将这其中的字符串表现形式转换成基本数据类型。

String s = "true";
boolean b = Boolean.parseBoolean(s);

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

JDK5的新特性

  • 自动装箱:把基本类型转换为包装类型
  • 自动拆箱:把包装类类型转换为基本类型
int x = 100;
Integer i1 = new Integer(x);//把基本数据类型包装成对象,装箱

int y = i1.intValue();//把对象转换为基本数据类型,拆箱

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

注意:
Integer x = null;代码会出现NullPointerException
建议先判断是否为null然后再使用。

Integer面试题:

Integer i1 = new Integer(97);
Integer i2 = new Integer(97);
System.out.println(i1 == i2);//false
System.out.println(i1.equals(i2));//Integer重写了equals方法 true

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

//自动装箱
Integer i5 = 127;
Integer i6 = 127;
System.out.println(i5 == i6);//true
System.out.println(i5.equals(i6));//true
// -128到127是byte的取值范围,如果在这个范围内自动装箱就不会新创建对象,而是从常量池中获取。

//如果超出这个部分
Integer i7 = 128;
Integer i9 = 128;
System.out.println(i7 == i9);//false
System.out.println(i7.equals(i9));//true


//看源码

本文链接:

https://heyzen.club/index.php/J/239.html
1 + 9 =
快来做第一个评论的人吧~