StringBuffer、StringBuilder、冒泡与选择排序、二分查找、基本数据类型包装类_DAY13

1:数组的高级操作(预习)

(1)数组:存储同一种数据类型的多个元素的容器。

(2)特点:每个元素都有从0开始的编号,方便我们获取。专业名称:索引。

(3)数组操作:

A:遍历

public static void printArray(int[] arr) {

for(int x=0; x<arr.length; x++) {

System.out.println(arr[x]);

}

}

B:获取最值

public static int getMax(int[] arr) {

int max = arr[0];

for(int x=1; x<arr.length; x++) {

if(arr[x]>max) {

max = arr[x];

}

}

return max;

}

C:排序

a:冒泡排序

原理:相邻元素两两比较,大的往后放。第一次完毕,最大值在最大索引处。

public static void bubbleSort(int[] arr) {

for(int x=0; x<arr.length-1; x++) {  //外层循环控制轮数 ,一共要比较(arr.length-1)轮

for(int y=0; y<arr.length-1-x; y++) {  //外层循环控制每一轮比较的次数,每一轮比较(arr.length-1-i)次

if(arr[y] > arr[y+1]) {      //如果前面的元素比后面的元素大,则交换位置

int temp = arr[y];

arr[y] = arr[y+1];

arr[y+1] = temp;

}

}

}

}

注释:冒泡排序原理图

b:选择排序

原理:从0索引元素开始,依次和后面的所有元素比较,小的往0索引处放。

第一次完毕后,最小值在最小索引处。

public static void selectSort(int[] arr) {

for(int x=0; x<arr.length-1; x++) {

for(int y=x+1; y<arr.length; y++) {

if(arr[y]>arr[x]) {

int temp = arr[y];

arr[y] = arr[x];

arr[x] = temp;

}

}

}

}

D:查找

a:普通查找

原理:遍历数组,从头找到尾

public static int getIndex(int[] arr,int value) {

int index = -1;

for(int x=0; x<arr.length; x++) {

if(arr[x]==value) {

index = x;

break;

}

}

return index;

}

b:二分查找(折半查找)

前提:数组必须是有序的。

原理:每次都从中间开始找,如果比中间数据小,就在左边找,

如果比中间数据大,就在右边找,如果相等,就返回中间的索引值。

public static int getIndex(int[] arr,int value) {

int start = 0;

int end = arr.length-1;

int mid = (start+end)/2;

while(arr[mid]!=value){

if(value>arr[mid]) {

start = mid + 1;

}else if(value<arr[mid]) {

end = mid - 1;

}

if(start > end) {

return -1;

}

mid = (start+end)/2;

}

return mid;

}

2:Arrays工具类的使用(掌握)

(1)Arrays是针对数组进行操作的工具类。

(2)要掌握的功能:

A:把数组转成字符串

public static String toString(int[] arr)

B:排序

public static void sort(int[] arr)

C:二分查找

public static int binarySearch(int[] arr,int value)  //返回数字在数组中的索引

例子3.demo3

/*
 * 从数组当中找到4所在的索引:
 *         {2,4,6,7,43,57,90,101}
 */
public class Demo3 {

    public static void main(String[] args) {

        int[] arr = {2,4,6,7,43,57,90,101};
        int number = 10;
        System.out.(method(arr, number));

    }

    public static int method(int[] arr,int number){

        int start = 0; //定义变量,记录最小的索引
        int end = arr.length-1; //定义变量,记录最大的索引
        int mid = (start+end)/2; //定义变量,记录中间的索引

        while(arr[mid]!=number) {  //只要查找的数不等于数组中间的数,就继续查找,如果中间的数等于查找的数,则mid就是要求的索引

            if(number<arr[mid]) {  //如果这个数比数组中间的数小,则让最大的索引=mid-1
                end = mid-1;
            }else if(number>arr[mid]) {  //如果这个数比数组中间的数大,则让最小的所用=mid+1
                start = mid+1;
            }

            if(start>end) {    //如果出现最小索引大于最大索引的情况,说明数组中不存在这样的元素
                return -1;
            }

            mid = (start+end)/2;  //每次循环后,因为首尾的索引变化了,所以中间的索引也需要变化
        }

        return mid;  //如果数组中有这个元素,则返回
    }

}

(3)Arrays工具类的源码。(理解)

3:StringBuffer类(掌握)

(1)StringBuffer:是字符串缓冲区类,容量可以改变。

(2)面试题:

String和StringBuffer的区别?

String的长度固定。

StringBuffer的长度可变。

StringBuffer和StringBuilder的区别?

StringBuffer的线程安全,效率低。

String的线程不安全,效率高。

例子:deme0

/*
 *     StringBuffer:String的缓冲区,用于提高效率,拼写字符串。
 */
public class Demo {

    public static void main(String[] args) {

        int[] arr = {1,2,3,4,5};
        String s = "";

        for (int i = 0; i < arr.length; i++) {
            s += arr[i];
        }

        System.out.println(s);
               //循环结束后,创建了6个String对象,但是最终只打印一个对象。浪费了内空间。
    }

}

(3)StringBuffer的构造方法

A:StringBuffer sb = new StringBuffer();//初始容量默认为16

B:StringBuffer sb = new StringBuffer(int capacity);  //capacity指定初始容量

C:StringBuffer sb = new StringBuffer(String s); //给sb赋值

注意:StringBuilder的功能和StringBuffer一模一样。前者是JDK5以后出现的。

(4)要掌握的功能:(请自己把对应的方法写出来)

A:添加功能 public StringBuffer append(X b) ; public StringBuffer insert(int offset,X b)

B:删除功能 public StringBuffer delete(int start,int end) ; public StringBuffer deleteCharAt(int index)

demo2

/*
 * StringBuffer的构造:
 *         1:注意:长度与容量不同。
 *         public StringBuffer() 构造一个其中不带字符的字符串缓冲区,其初始容量为 16 个字符。
 *         public StringBuffer(String str)  构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。
 *         public StringBuffer(int capacity) 构造一个不带字符,但具有指定初始容量的字符串缓冲区。
 *
 * StringBuffer的普通方法:
 *         2:public int capacity()  返回当前对象的容量
 *         3:public int length()  返回当前对象的长度,即字符数
 * StringBuffer的添加&删除:
 *         4:public StringBuffer append(X b)  及其重载  追加任意内容到字符串缓冲区,返回:此对象的一个引用。
 *         表示X表示任意类型,注意链式编程。
 *      5:public StringBuffer insert(int offset,X b)  将任意参数的字符串表示形式插入此序列中。
 *      6:public StringBuffer delete(int start,int end) 删除指定内容 ,包含头,不包含尾
 *        public StringBuffer deleteCharAt(int index) 删除指定位置字符
 */
public class Demo2 {

    public static void main(String[] args) {

        //1,2,3:
        StringBuffer sb = new StringBuffer();
        StringBuffer sb2 = new StringBuffer("i love java");
        StringBuffer sb3 = new StringBuffer(100);

        System.out.println(sb.capacity());
        System.out.println(sb.length());
        System.out.println(sb2.capacity());
        System.out.println(sb2.length());
        System.out.println(sb3.capacity());
        System.out.println(sb3.length());

        //4:public StringBuffer append(X b)  及其重载 ,追加任意内容到字符串缓冲区,返回:此对象的一个引用。
        StringBuffer sb4 = new StringBuffer("i love java");
        System.out.println(sb4);

//        sb4.append(false);
//        sb4.append(10);
//        sb4.append("巴马学编程");
//        sb4.append(1.1);
//        sb4.append(new Demo());
//        System.out.println(sb4);

        System.out.println(new StringBuffer("i love java")//链式编程形式
                        .append(false)
                        .append(10)
                        .append("巴马学编程")
                        .append(1.1)
                        .append(new Demo2()));

        //5:public StringBuffer insert(int offset,X b)  将任意参数的字符串表示形式插入此序列中。
        StringBuffer sb5 = new StringBuffer("i love java");
        System.out.println(sb5);

        System.out.println(sb5.insert(2, "abcd"));
        System.out.println(sb5.insert(2, "abcd").insert(4, "zxcv"));

//        6:public StringBuffer delete(int start,int end) 删除指定内容
//        public StringBuffer deleteCharAt(int index) 删除指定位置字符
        StringBuffer sb6 = new StringBuffer("i love java");

        StringBuffer deleteCharAt = sb6.deleteCharAt(0);
        System.out.println(deleteCharAt);
        //sb6: love java
        StringBuffer delete = sb6.delete(0, 5);
        System.out.println(delete); //包含头,不包含尾
                // java
        //只要确定始终为一个对象即可。即sb6与deleteCharAt与delete都是同一个对象
    }

}

C:其他功能

替换功能 public StringBuffer replace(int start, int end, String str)

截取功能 public String substring(int start); public String substring(int start,int end)

反转功能 public StringBuffer reverse()

转换为String类型  toString();

demo3

/*
 *  StringBuffer的替换&反转&截取:
 *      1:public StringBuffer replace(int start, int end, String str)  使用给定 String 中的字符替换此序列的子字符串中的字符。含头不含尾
 *      2:public StringBuffer reverse()  倒过来
 *      3:public String substring(int start)   截取,含头不含尾
 *        public String substring(int start,int end)
 *      4:toString()方法被重写了,其作用是:StringBuffer类型的对象不能直接给String类型赋值,需要先转换为String类型
 */
public class Demo3 {

    public static void main(String[] args) {

        //1:
        StringBuffer sb = new StringBuffer("i love java");

        System.out.println(sb.replace(2, 6, "like"));   //含头不含尾
        System.out.println(sb.replace(2, 6, "lovelovelove"));

        //2:
        StringBuffer sb2 = new StringBuffer("i love java");
        System.out.println(sb2.reverse());

        //3:
        StringBuffer sb3 = new StringBuffer("i love java");
        System.out.println(sb3.substring(2));
        System.out.println(sb3.substring(2,4));  //含头不含尾

        //4:
//        String s = sb3;   //StringBuffer类型的对象不能直接给String类型赋值,需要先转换为String类型
        String s = sb3.toString();
        System.out.println(s);
    }

}

(5)案例:

把一个字符串反转。

public class test{

public static void main(String[] args) {

String s="I love you";

StringBuffer stringBuffer=new StringBuffer(s);

stringBuffer.reverse();

System.out.println(stringBuffer);

}

}

4:基本数据类型包装类(掌握)

(1)由于我们对基本类型只能做一些最简单的操作,

为了让我们有更多的操作,java就针对每种基本类型提供了保证类。

(2)八种基本类型对应的包装类是谁?

byte   Byte

short  Short

int Integer

long   Long

float  Float

double Double

char   Character

boolean Boolean

(3)Integer类的构造方法

A:Integer i = new Integer(int x);

B:Integer i = new Integer(String s);

注意:这里的s必须是有数字字符组成的字符串。

(4)Integer类的其他方法

public static String toBinaryString(int i)  十进制转成二进制

public static String toHexString(int i)  十进制转成十六进制

public static String toOctalString(int i)  十进制转成八进制

例子3.demo6

/*
 * Integer的其他方法:
 *         public static String toBinaryString(int i)  十进制转成二进制
 *         public static String toHexString(int i)  十进制转成十六进制
 *         public static String toOctalString(int i)  十进制转成八进制
 */
public class Demo6 {

    public static void main(String[] args) {

        int x = 27;

        System.out.println(Integer.toBinaryString(x));
        System.out.println(Integer.toHexString(x));
        System.out.println(Integer.toOctalString(x));
    }

}

(5)Integer的功能

A:String -- int

String s = "100";

int i = Integer.parseInt(s);

B:int -- String

int i = 100;

String s = String.valueOf(i);

(6)JDK5以后的新特性

A:自动装箱 从int--Integer

B:自动拆箱 从Integer--int

请大家解释下面的代码:哪里体现了自动装箱,哪里体现了自动拆箱

Integer i = 100;  //自动装箱

i += 200; //先自定拆箱,再自动装箱

System.out.println(i);

例子3.demo7

/*
 * 基本类型包装类:
 *         自动装箱拆箱
 *         装箱:基本类型>>包装类对象
 *         拆箱:包装类对象>>基本类型
 */
public class Demo7 {

    public static void main(String[] args) {

        int a = 10;
        int b = 20;
        System.out.println(a+b);

        Demo7 demo7 = new Demo7();
        Demo7 demo72 = new Demo7();
        //System.out.println(demo7+demo72);  引用数据类型不能直接相加
        //自动拆箱
        Integer i = new Integer(a);
        Integer i2 = new Integer(b);
        System.out.println(i+i2);

        //自动装箱
        Integer i3 = 10;
        Integer i4 = 200;

        //以下内容做了什么?
        Integer x = 1;  //自动装箱
        x = x + 1;  //先拆箱,再装箱

        //直接使用引用数据类型计算时,注意空值的问题
        Integer i5 = 10;
        Integer i6 = null;

        System.out.println(i5+i6);
    }

}

注意:

让我们操作变得简单,但是隐含了一个问题,这个时候,我们在使用对象前,最好做不为空的校验。例如:

//直接使用引用数据类型计算时,注意空值的问题

Integer i5 = 10;

Integer i6 = null;

System.out.println(i5+i6); //相加是先自动拆箱,相加时会报空指异常针

(7)面试题:

byte常量池:java虚拟机为了优化8种基本数据类型的包装对象都提供了缓冲池,缓冲池有大小,一个字节。

/*
 * java虚拟机为了优化8种基本数据类型的包装对象都提供了缓冲池,缓冲池有大小,一个字节。
 */
public class Demo {

    public static void main(String[] args) {

        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2); //false

        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4); //false

        Integer i5 = 128;
        Integer i6 = 128;
        System.out.println(i5 == i6); //false
        Integer i7 = -127;
        Integer i8 = -127;
        System.out.println(i7 == i8); //true

        //1byte = -128~127

    }
}

(8)案例:

把字符串"-34 29 76 11 27"中的数据排序并输出。

import java.util.Arrays;
/**
 * 把字符串"-34 29 76 11 27"中的数据排序并输出。
 */
public class test3 {
    public static void main(String[] args) {
        String s = "-34 29 76 11 27";
        String[] s2 = s.split(" "); // 按照空格分割字符
        int[] a=new int[s2.length]; //存储数字的字符串

        for (int i = 0; i < s2.length; i++) {
           a[i]=Integer.parseInt(s2[i]); //String[]转int[]
        }
        Arrays.sort(a);  //排序
        System.out.println(Arrays.toString(a));//转换成字符串输出
    }
}

5、题目

(1)使用StringBuilder/StringBuffer完成将一个数组内内容拼写到一个字符串当中。

/**
 * 使用StringBuilder/StringBuffer完成将一个数组内内容拼写到一个字符串当中
 */
public class test {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5};
        StringBuilder stringBuilder=new StringBuilder();

        for(int i=0;i<a.length;i++ ){
            stringBuilder.append(a[i]);
        }

        String s=stringBuilder.toString();
        System.out.println(s);
    }
}

(2):以下程序做了什么事?

Integer x = 1; //自动装箱

x = x + 1; //先自动拆箱,再自动装箱

时间: 2024-10-10 20:25:24

StringBuffer、StringBuilder、冒泡与选择排序、二分查找、基本数据类型包装类_DAY13的相关文章

8.8 冒泡排序 选择排序 二分查找 递归使用

冒泡排序: #include <stdio.h> #include <stdlib.h> #include <time.h> #define N 100000 #define M 100000 void show_arr(int * a,int n) { int i; for(i = 0; i < n; i++) { printf("%d ",a[i]); } printf("\n"); } void init_arr(in

基于python语言的经典排序法(冒泡法和选择排序法)

前 每逢周末就遇雨期,闲暇之余,捣鼓了下python,心心念想学习,今天就在电脑上装了个2.7,学习了下经典算法,冒泡与选择排序法 第一次写关于python的文章,说的不当之处,多多指正,我积极改正 在之前,曾写过使用java和C语言实现该两种排序法,详情见https://www.cnblogs.com/hong-fithing/p/7615907.html 搭建环境,准备工作就不冗余介绍了,网上搜罗一大堆 目录 冒泡排序法 选择排序法 冒泡排序法 冒泡类似于汽水现象,摇动一下,就有很多泡往上冒

Java基础【冒泡、选择排序、二分查找】

冒泡排序的思路就是前一个和后一个进行比较,如果大的就交换位置   大的数字后浮 如   12      8    5     31 第一轮   8   5   12   31 第二轮   5   8    12   31 ........ 代码如下 package com.zuoyan.sort; /** * 冒泡排序 * @author Administrator * */ public class BubbloSortDemo { public static void main(String

算法: 二分查找 冒泡 插入 选择排序

1 二分查找:二分查找从有序列表的候选区data[0:n]开始,通过对半查找的值与候选区中间的值进行比较 方法一:利用for循环, 时间复杂度是o(n) li = [1, 3, 5, 7, 9, 11, 15, 18, 20] def linear_serach(li, value): for i in range(len(li)): if li[i] == value: return i return print(linear_serach(li,3)) 方法二: 利用二分查找, 效率高, 时

链表上的冒泡、选择排序算法

做如下定义 typedef struct LNode { int num; char name[20]; struct LNode *next; } LNode, *LinkList; 冒泡排序算法 void BubbleSort(LinkList &L) { LinkList i = NULL, j = NULL; for (i = L; i->next->next != NULL; i = i->next) { for (j =i ; j->next->next

c语言冒泡和选择排序

冒泡排序代码: //冒泡排序 void arr(){     int arr[] = {3,2,4,1};     int count = sizeof(arr)/sizeof(arr[0]);     for (int i=0; i<count-1; i++) {         for (int j=0; j<count-i-1; j++) {                         if (arr[j]<arr[j+1]) {                 int tem

算法小结-冒泡、选择排序、直接插入排序

1.冒泡排序法:比较相邻的两个元素,如果前边比后边大,就对调两元素,一趟下来,最大的数放在最右边,就像泡泡上升一样. 代码: /* * 冒泡 */ static void bubble_sort(int[] array) { for (int i = 0; i < array.length; i++) { for (int j = i; j < array.length; j++) { if (array[i] > array[j]) { int temp = array[i]; arr

一招教你搞定c语言中冒泡和选择排序

一.选择排序 很多学习C语言的同学都被这两种排序而难倒.每次拿到这样一组数字就不知道从何下手了,要不就是那些运用的不太熟悉,每次写起代码来又得花一大半时间让费在这排序上,总是找不到一种好的办法去学习它.那么接下来,我将我所学到的排序方法分享给大家,告诉你们以后遇到这种排序千万不能急.当然,很多企业面试的时候种排序也是必考的,所以我们务必要把他们搞懂,不能让这么小小的排序阻挡了我们前进的步伐.好了,那我们来看看吧! 我选择的方法是函数调用的方法,将排序的具体方式通过函数调用到main函数中执行,具

冒泡法和选择排序法(比较容易写混)

1 #include<stdio.h> 2 3 4 //冒泡排序法 5 6 void bubbling(int a[],int n); 7 8 //选择排序法 9 void choose(int a[],int n); 10 int main() 11 { 12 int i; 13 int s[6]; 14 printf("please enter five numbers:\n"); 15 for(i=1;i<6;i++) 16 { 17 scanf("%