Java基础13-总结StringBuffer,StringBuilder,数组高级,Arrays,Integer,Character-阿里云开发者社区

开发者社区> 安全> 正文
登录阅读全文

Java基础13-总结StringBuffer,StringBuilder,数组高级,Arrays,Integer,Character

简介: 你需要的是什么,直接评论留言。 获取更多资源加微信公众号“Java帮帮” (是公众号,不是微信好友哦) 还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读 学习交流请加Java帮帮交流QQ群553841695 分享是一种美德,分享更快乐! 1:StringBuffer(掌握) (1)用字符串做拼接,比较耗时并且也耗内存,而

你需要的是什么,直接评论留言。

获取更多资源加微信公众号“Java帮帮” (是公众号,不是微信好友哦)

还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读

学习交流请加Java帮帮交流QQ群553841695

分享是一种美德,分享更快乐!

1:StringBuffer(掌握)

(1)用字符串做拼接,比较耗时并且也耗内存,而这种拼接操作又是比较常见的,为了解决这个问题,Java就提供了

   一个字符串缓冲区类。StringBuffer供我们使用。

(2)StringBuffer的构造方法

A:StringBuffer()

B:StringBuffer(int size)

C:StringBuffer(String str)


/*

 * 线程安全(多线程讲解)

 * 安全 -- 同步 -- 数据是安全的

 * 不安全 -- 不同步 -- 效率高一些

 * 安全和效率问题是永远困扰我们的问题。

 * 安全:医院的网站,银行网站

 * 效率:新闻网站,论坛之类的

 * 

 * StringBuffer:

 * 线程安全的可变字符串。

 * 

 * StringBuffer和String的区别?

 * 前者长度和内容可变,后者不可变。

 * 如果使用前者做字符串的拼接,不会浪费太多的资源。

 * 

 * StringBuffer的构造方法:

 * public StringBuffer()            :无参构造方法   初始化一个默认容量的字符串缓冲区对象

 *public StringBuffer(int capacity):       初始化具有一个指定容量的字符串缓冲区对象

 *public StringBuffer(String str)  :             初始化一个具有初始化值(指定)的字符串内容的字符串缓冲区对象

 *

 * StringBuffer的方法:

 *public int capacity():返回当前容量。理论值

 *public int length()  :返回长度(字符数)。 实际值

 */

public class StringBufferDemo {

public static void main(String[] args) {

// public StringBuffer():无参构造方法

StringBuffer sb = new StringBuffer();

System.out.println("sb:" + sb);

System.out.println("sb.capacity():" + sb.capacity());

System.out.println("sb.length():" + sb.length());

System.out.println("--------------------------");


// public StringBuffer(int capacity):指定容量的字符串缓冲区对象

StringBuffer sb2 = new StringBuffer(50);

System.out.println("sb2:" + sb2);

System.out.println("sb2.capacity():" + sb2.capacity());

System.out.println("sb2.length():" + sb2.length());

System.out.println("--------------------------");


// public StringBuffer(String str):指定字符串内容的字符串缓冲区对象

StringBuffer sb3 = new StringBuffer("hello");

System.out.println("sb3:" + sb3);

System.out.println("sb3.capacity():" + sb3.capacity());

System.out.println("sb3.length():" + sb3.length());

}

}



(3)StringBuffer的常见功能(自己补齐方法的声明和方法的解释)

A:添加功能


/*

 * StringBuffer的添加功能:

 * public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身

 * 

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

 */     添加在offset前面。

public class StringBufferDemo {

public static void main(String[] args) {

// 创建字符串缓冲区对象

StringBuffer sb = new StringBuffer();


// public StringBuffer append(String str)

// StringBuffer sb2 = sb.append("hello");

// System.out.println("sb:" + sb);

// System.out.println("sb2:" + sb2);

// System.out.println(sb == sb2); // true


// 一步一步的添加数据

// sb.append("hello");

// sb.append(true);

// sb.append(12);

// sb.append(34.56);


// 链式编程

sb.append("hello").append(true).append(12).append(34.56);

System.out.println("sb:" + sb);


// public StringBuffer insert(int offset,String

// str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

sb.insert(5, "world");

System.out.println("sb:" + sb);

}

}



B:删除功能


/*

 * StringBuffer的删除功能

 * public StringBuffer deleteCharAt(int index)  :删除指定位置的字符,并返回本身

 * public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容,不包含结束位置内容,并返回本身

 */

public class StringBufferDemo {

public static void main(String[] args) {

// 创建对象

StringBuffer sb = new StringBuffer();


// 添加功能

sb.append("hello").append("world").append("java");

System.out.println("sb:" + sb);


// public StringBuffer deleteCharAt(int index):删除指定位置的字符,并返回本身

// 需求:我要删除e这个字符,肿么办?

// sb.deleteCharAt(1);

// 需求:我要删除第一个l这个字符,肿么办?

// sb.deleteCharAt(1);


// public StringBuffer delete(int start,int

// end):删除从指定位置开始指定位置结束的内容,并返回本身

// 需求:我要删除world这个字符串,肿么办?

// sb.delete(5, 10);


// 需求:我要删除所有的数据

sb.delete(0, sb.length());


System.out.println("sb:" + sb);

}

}



C:替换功能


/*

 * StringBuffer的替换功能:

 * public StringBuffer replace(int start,int end,String str)

 *:从start位置开始到end位置对应的字符串用str这个字符串替换返回字符串缓冲区本身,不包含end位置对应的字符

 */

public class StringBufferDemo {

public static void main(String[] args) {

// 创建字符串缓冲区对象

StringBuffer sb = new StringBuffer();


// 添加数据

sb.append("hello");

sb.append("world");

sb.append("java");

System.out.println("sb:" + sb);


// public StringBuffer replace(int start,int end,String

// str):从start开始到end用str替换

// 需求:我要把world这个数据替换为"节日快乐"

sb.replace(5, 10, "节日快乐");

System.out.println("sb:" + sb);

}

}



D:反转功能


//public StringBuffer reverse()    返回字符串本身


/*

 * StringBuffer的反转功能:

 * public StringBuffer reverse()

 */

public class StringBufferDemo {

public static void main(String[] args) {

// 创建字符串缓冲区对象

StringBuffer sb = new StringBuffer();


// 添加数据

sb.append("霞青林爱我");

System.out.println("sb:" + sb);


// public StringBuffer reverse()

sb.reverse();

System.out.println("sb:" + sb);

}

}


E:截取功能(注意这个返回值)


/*

 * StringBuffer的截取功能:注意返回值类型不再是StringBuffer本身了

 * public String substring(int start)           截取从start开始到末尾,返回的是被截取到的字符

 * public String substring(int start,int end)   截取从指定位置开始到结束位置,包括开始位置,不包括结束位置;

 */

public class StringBufferDemo {

public static void main(String[] args) {

// 创建字符串缓冲区对象

StringBuffer sb = new StringBuffer();


// 添加元素

sb.append("hello").append("world").append("java");

System.out.println("sb:" + sb);


// 截取功能

// public String substring(int start)

String s = sb.substring(5);

System.out.println("s:" + s);

System.out.println("sb:" + sb);


// public String substring(int start,int end)

String ss = sb.substring(5, 10);

System.out.println("ss:" + ss);

System.out.println("sb:" + sb);

}

}



(4)StringBuffer的练习(做一遍)

A:String和StringBuffer相互转换

String -- StringBuffer

构造方法              append方法

StringBuffer -- String

建议:toString()方法


/*

 * 为什么我们要讲解类之间的转换:      其实是想使用StringBuffer中特有的功能

 * A -- B的转换

 * 我们把A转换为B,其实是为了使用B的功能。

 * B -- A的转换

 * 我们可能要的结果是A类型,所以还得转回来。

 * 

 * String和StringBuffer的相互转换?

 */

public class StringBufferTest {

public static void main(String[] args) {

// String -- StringBuffer

String s = "hello";

// 注意:不能把字符串的值直接赋值给StringBuffer

// StringBuffer sb = "hello";

// StringBuffer sb = s;

// 方式1:通过构造方法

StringBuffer sb = new StringBuffer(s);

// 方式2:通过append()方法

StringBuffer sb2 = new StringBuffer();

sb2.append(s);

System.out.println("sb:" + sb);

System.out.println("sb2:" + sb2);

System.out.println("---------------");



// StringBuffer -- String

StringBuffer buffer = new StringBuffer("java");

// String(StringBuffer buffer)

// 方式1:通过构造方法

String str = new String(buffer);

// 方式2:通过toString()方法

String str2 = buffer.toString();

System.out.println("str:" + str);

System.out.println("str2:" + str2);

}

}



B:字符串的拼接


/*

 * 把数组拼接成一个字符串

 */

public class StringBufferTest2 {

public static void main(String[] args) {

// 定义一个数组

int[] arr = { 44, 33, 55, 11, 22 };


// 定义功能

// 方式1:用String做拼接的方式

String s1 = arrayToString(arr);

System.out.println("s1:" + s1);


// 方式2:用StringBuffer做拼接的方式

String s2 = arrayToString2(arr);

System.out.println("s2:" + s2);

}


// 用StringBuffer做拼接的方式

public static String arrayToString2(int[] arr) {

StringBuffer sb = new StringBuffer();


sb.append("[");

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

if (x == arr.length - 1) {

sb.append(arr[x]);

} else {

sb.append(arr[x]).append(", ");

}

}

sb.append("]");


return sb.toString();

}


// 用String做拼接的方式

public static String arrayToString(int[] arr) {

String s = "";


s += "[";

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

if (x == arr.length - 1) {

s += arr[x];

} else {

s += arr[x];

s += ", ";

}

}

s += "]";


return s;

}

}



C:把字符串反转


import java.util.Scanner;


/*

 * 把字符串反转

 */

public class StringBufferTest3 {

public static void main(String[] args) {

// 键盘录入数据

Scanner sc = new Scanner(System.in);

System.out.println("请输入数据:");

String s = sc.nextLine();


// 方式1:用String做拼接

String s1 = myReverse(s);

System.out.println("s1:" + s1);

// 方式2:用StringBuffer的reverse()功能

String s2 = myReverse2(s);

System.out.println("s2:" + s2);

}


// 用StringBuffer的reverse()功能

public static String myReverse2(String s) {

// StringBuffer sb = new StringBuffer();

// sb.append(s);


// StringBuffer sb = new StringBuffer(s);

// sb.reverse();

// return sb.toString();


// 简易版

return new StringBuffer(s).reverse().toString();

}


// 用String做拼接

public static String myReverse(String s) {

String result = "";


char[] chs = s.toCharArray();

for (int x = chs.length - 1; x >= 0; x--) {

// char ch = chs[x];

// result += ch;

result += chs[x];

}


return result;

}

}



D:判断一个字符串是否对称


import java.util.Scanner;


/*

 * 判断一个字符串是否是对称字符串

 * 例如"abc"不是对称字符串,"aba"、"abba"、"aaa"、"mnanm"是对称字符串

 * 

 * 分析:

 * 判断一个字符串是否是对称的字符串,我只需要把

 * 第一个和最后一个比较

 * 第二个和倒数第二个比较

 * ...

 * 比较的次数是长度除以2。

 */

public class StringBufferTest4 {

public static void main(String[] args) {

// 创建键盘录入对象

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个字符串:");

String s = sc.nextLine();


// 一个一个的比较

boolean b = isSame(s);

System.out.println("b:" + b);

//用字符串缓冲区的反转功能

boolean b2 = isSame2(s);

System.out.println("b2:"+b2);

}

public static boolean isSame2(String s) {

return new StringBuffer(s).reverse().toString().equals(s);

}


// public static boolean isSame(String s) {

// // 把字符串转成字符数组

// char[] chs = s.toCharArray();

//

// for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {

// if (chs[start] != chs[end]) {

// return false;

// }

// }

//

// return true;

// }


public static boolean isSame(String s) {

boolean flag = true;


// 把字符串转成字符数组

char[] chs = s.toCharArray();


for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {

if (chs[start] != chs[end]) {

flag = false;

break;

}

}


return flag;

}

}



(5)面试题

小细节:

StringBuffer  :同步的,数据安全,效率低。

StringBuilder :不同步的,数据不安全,效率高。


A:String,StringBuffer,StringBuilder的区别

B:StringBuffer和数组的区别?

/*

 * 面试题:

 * A:String,StringBuffer,StringBuilder的区别?

 * A:String是内容不可变的,而StringBuffer,StringBuilder都是内容可变的。

 * B:StringBuffer是同步的,数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高

 * 

 *B:StringBuffer和数组的区别?

 * 二者都可以看出是一个容器,装其他的数据。

 * 但是呢,StringBuffer的数据最终是一个字符串数据。

 * 而数组可以放置多种数据,但必须是同一种数据类型的。

 */ 



(6)注意的问题:

String作为形式参数,StringBuffer作为形式参数。


/*形式参数问题

 * String作为参数传递

 * StringBuffer作为参数传递 

 * 

 * 形式参数:

 * 基本类型:形式参数的改变不影响实际参数

 * 引用类型:形式参数的改变直接影响实际参数

 * 

 * 注意:

 * String作为参数传递,效果和基本类型作为参数传递是一样的。

 */

public class StringBufferDemo {

public static void main(String[] args) {

String s1 = "hello";

String s2 = "world";

System.out.println(s1 + "---" + s2);// hello---world

change(s1, s2);

System.out.println(s1 + "---" + s2);// hello---world


StringBuffer sb1 = new StringBuffer("hello");

StringBuffer sb2 = new StringBuffer("world");

System.out.println(sb1 + "---" + sb2);// hello---world

change(sb1, sb2);

System.out.println(sb1 + "---" + sb2);// hello---worldworld


}


public static void change(StringBuffer sb1, StringBuffer sb2) {

sb1 = sb2;

sb2.append(sb1);

}


public static void change(String s1, String s2) {

s1 = s2;

s2 = s1 + s2;

}

}



2:数组高级以及Arrays(掌握)

(1)排序

A:冒泡排序

相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处。同理,其他的元素就可以排好。

public static void bubbleSort(int[] arr) {

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

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

if(arr[y] > arr[y+1]) {

int temp = arr[y];

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

arr[y+1] = temp;

}

}

}

}


/*

 * 数组排序之冒泡排序:

 * 相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处

 */

public class ArrayDemo {

public static void main(String[] args) {

// 定义一个数组

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

System.out.println("排序前:");

printArray(arr);


/*

// 第一次比较

// arr.length - 1是为了防止数据越界

// arr.length - 1 - 0是为了减少比较的次数

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

if (arr[x] > arr[x + 1]) {

int temp = arr[x];

arr[x] = arr[x + 1];

arr[x + 1] = temp;

}

}

System.out.println("第一次比较后:");

printArray(arr);


// 第二次比较

// arr.length - 1是为了防止数据越界

// arr.length - 1 - 1是为了减少比较的次数

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

if (arr[x] > arr[x + 1]) {

int temp = arr[x];

arr[x] = arr[x + 1];

arr[x + 1] = temp;

}

}

System.out.println("第二次比较后:");

printArray(arr);


// 第三次比较

// arr.length - 1是为了防止数据越界

// arr.length - 1 - 2是为了减少比较的次数

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

if (arr[x] > arr[x + 1]) {

int temp = arr[x];

arr[x] = arr[x + 1];

arr[x + 1] = temp;

}

}

System.out.println("第三次比较后:");

printArray(arr);


// 第四次比较

// arr.length - 1是为了防止数据越界

// arr.length - 1 - 3是为了减少比较的次数

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

if (arr[x] > arr[x + 1]) {

int temp = arr[x];

arr[x] = arr[x + 1];

arr[x + 1] = temp;

}

}

System.out.println("第四次比较后:");

printArray(arr);

*/


// 既然听懂了,那么上面的代码就是排序代码

// 而上面的代码重复度太高了,所以用循环改进

// for (int y = 0; y < 4; y++) {

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

// if (arr[x] > arr[x + 1]) {

// int temp = arr[x];

// arr[x] = arr[x + 1];

// arr[x + 1] = temp;

// }

// }

// }


/*

// 由于我们知道比较的次数是数组长度-1次,所以改进最终版程序

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

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

if (arr[y] > arr[y + 1]) {

int temp = arr[y];

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

arr[y + 1] = temp;

}

}

}

System.out.println("排序后:");

printArray(arr);

*/

//由于我可能有多个数组要排序,所以我要写成方法

bubbleSort(arr);

System.out.println("排序后:");

printArray(arr);

}

//冒泡排序代码

public static void bubbleSort(int[] arr){

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

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

if (arr[y] > arr[y + 1]) {

int temp = arr[y];

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

arr[y + 1] = temp;

}

}

}

}


// 遍历功能

public static void printArray(int[] arr) {

System.out.print("[");

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

if (x == arr.length - 1) {

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

} else {

System.out.print(arr[x] + ", ");

}

}

System.out.println("]");

}

}


B:选择排序

把0索引的元素,和索引1以后的元素都进行比较,第一次完毕,最小值出现在了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[x];

arr[x] = arr[y];

arr[y] = temp;

}

}

}

}


/*

 * 数组排序之选择排序:

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

 */

public class ArrayDemo {

public static void main(String[] args) {

// 定义一个数组

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

System.out.println("排序前:");

printArray(arr);


/*

// 第一次

int x = 0;

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

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

int temp = arr[x];

arr[x] = arr[y];

arr[y] = temp;

}

}

System.out.println("第一次比较后:");

printArray(arr);


// 第二次

x = 1;

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

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

int temp = arr[x];

arr[x] = arr[y];

arr[y] = temp;

}

}

System.out.println("第二次比较后:");

printArray(arr);


// 第三次

x = 2;

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

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

int temp = arr[x];

arr[x] = arr[y];

arr[y] = temp;

}

}

System.out.println("第三次比较后:");

printArray(arr);


// 第四次

x = 3;

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

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

int temp = arr[x];

arr[x] = arr[y];

arr[y] = temp;

}

}

System.out.println("第四次比较后:");

printArray(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[x];

arr[x] = arr[y];

 arr[y] = temp;

}

}

}

System.out.println("排序后:");

printArray(arr);

*/

//用方法改进

selectSort(arr);

System.out.println("排序后:");

printArray(arr);


}

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[x];

arr[x] = arr[y];

 arr[y] = temp;

}

}

}

}


// 遍历功能

public static void printArray(int[] arr) {

System.out.print("[");

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

if (x == arr.length - 1) {

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

} else {

System.out.print(arr[x] + ", ");

}

}

System.out.println("]");

}

}



(2)查找

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 binarySearch(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) {

max = mid - 1;

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

min = mid + 1;

}

if(min > max) {

return -1;

}

mid = (min+max)/2;

}

return mid;

}

/*

 * 查找:

 * 基本查找:数组元素无序(从头找到尾)

 * 二分查找(折半查找):数组元素有序

 * 

 * 分析:

 * A:定义最大索引,最小索引

 * B:计算出中间索引

 * C:拿中间索引的值和要查找的值进行比较

 * 相等:就返回当前的中间索引

 * 不相等:

 * 左边找

 * 右边找

 * D:重新计算出中间索引

 * 左边找

 * max = mid - 1;

 * 右边找

 * min = mid + 1;

 * E:回到B

 */

public class ArrayDemo {

public static void main(String[] args) {

//定义一个数组

int[] arr = {11,22,33,44,55,66,77};

//写功能实现

int index = getIndex(arr, 33);

System.out.println("index:"+index);

//假如这个元素不存在后有什么现象呢?

index = getIndex(arr, 333);

System.out.println("index:"+index);

}

/*

 * 两个明确:

 * 返回值类型:int

 * 参数列表:int[] arr,int value

 */

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

//定义最大索引,最小索引

int max = arr.length -1;

int min = 0;

//计算出中间索引

int mid = (max +min)/2;

//拿中间索引的值和要查找的值进行比较

while(arr[mid] != value){

if(arr[mid]>value){

max = mid - 1;

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

min = mid + 1;

}

//加入判断

if(min > max){

return -1;

}

mid = (max +min)/2;

}

return mid;

}

}


package cn.itcast_04;


/*

 * 注意:下面这种做法是有问题的。

 * 因为数组本身是无序的,所以这种情况下的查找不能使用二分查找。

 * 所以你先排序了,但是你排序的时候已经改变了我最原始的元素索引。

 */

public class ArrayDemo2 {

public static void main(String[] args) {

// 定义数组

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


// 先排序

bubbleSort(arr);

// 后查找

int index = getIndex(arr, 80);

System.out.println("index:" + index);

}


// 冒泡排序代码

public static void bubbleSort(int[] arr) {

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

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

if (arr[y] > arr[y + 1]) {

int temp = arr[y];

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

arr[y + 1] = temp;

}

}

}

}


// 二分查找

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

// 定义最大索引,最小索引

int max = arr.length - 1;

int min = 0;


// 计算出中间索引

int mid = (max + min) / 2;


// 拿中间索引的值和要查找的值进行比较

while (arr[mid] != value) {

if (arr[mid] > value) {

max = mid - 1;

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

min = mid + 1;

}


// 加入判断

if (min > max) {

return -1;

}


mid = (max + min) / 2;

}


return mid;

}

}

(3)Arrays工具类

A:是针对数组进行操作的工具类。包括排序和查找等功能。

B:要掌握的方法(自己补齐方法)

把数组转成字符串:public static String toString(int[]a)

排序:       public static void sort(int[]a)

二分查找:      public static int binarySearch(int[]a,int key) 


import java.util.Arrays;


/*

 * Arrays:针对数组进行操作的工具类。比如说排序和查找。

 * 1:public static String toString(int[] a) 把数组转成字符串

 * 2:public static void sort(int[] a) 对数组进行排序

 * 3:public static int binarySearch(int[] a,int key) 二分查找

 */

public class ArraysDemo {

public static void main(String[] args) {

// 定义一个数组

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


// public static String toString(int[] a) 把数组转成字符串

System.out.println("排序前:" + Arrays.toString(arr));


// public static void sort(int[] a) 对数组进行排序

Arrays.sort(arr);

System.out.println("排序后:" + Arrays.toString(arr));


// [13, 24, 57, 69, 80]

// public static int binarySearch(int[] a,int key) 二分查找

System.out.println("binarySearch:" + Arrays.binarySearch(arr, 57));

System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));

}

}



(4)Arrays工具类的源码解析



public static String toString(int[] a)

public static void sort(int[] a) 底层是快速排序,知道就可以了。有空看,有问题再问我

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


开发原则:

只要是对象,我们就要判断该对象是否为null。


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

System.out.println("排序前:" + Arrays.toString(arr));


public static String toString(int[] a) {

//a -- arr -- { 24, 69, 80, 57, 13 }


    if (a == null)

        return "null"; //说明数组对象不存在

    int iMax = a.length - 1; //iMax=4;

    if (iMax == -1)

        return "[]"; //说明数组存在,但是没有元素。


    StringBuilder b = new StringBuilder();

    b.append('['); //"["

    for (int i = 0; ; i++) {

        b.append(a[i]); //"[24, 69, 80, 57, 13"

        if (i == iMax)

        //"[24, 69, 80, 57, 13]"

            return b.append(']').toString();

        b.append(", "); //"[24, 69, 80, 57, "

    }

}

-----------------------------------------------------


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

System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));


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

//a -- arr -- {13, 24, 57, 69, 80}

//key -- 577

    return binarySearch0(a, 0, a.length, key);

}


private static int binarySearch0(int[] a, int fromIndex, int toIndex,

                                 int key) {

    //a -- arr --  {13, 24, 57, 69, 80}

    //fromIndex -- 0

    //toIndex -- 5

    //key -- 577                           

                                 

                                 

    int low = fromIndex; //low=0

    int high = toIndex - 1; //high=4


    while (low <= high) {

        int mid = (low + high) >>> 1; //mid=2,mid=3,mid=4

        int midVal = a[mid]; //midVal=57,midVal=69,midVal=80


        if (midVal < key)

            low = mid + 1; //low=3,low=4,low=5

        else if (midVal > key)

            high = mid - 1;

        else

            return mid; // key found

    }

    return -(low + 1);  // key not found.

}



(5)把字符串中的字符进行排序

举例:

"edacbgf"

得到结果

"abcdefg"



package cn.itcast_03;


/*

 * 把字符串中的字符进行排序。

 * 举例:"dacgebf"

 * 结果:"abcdefg"

 * 

 * 分析:

 * A:定义一个字符串

 * B:把字符串转换为字符数组

 * C:把字符数组进行排序

 * D:把排序后的字符数组转成字符串

 * E:输出最后的字符串

 */

public class ArrayTest {

public static void main(String[] args) {

// 定义一个字符串

String s = "dacgebf";


// 把字符串转换为字符数组

char[] chs = s.toCharArray();


// 把字符数组进行排序

bubbleSort(chs);


//把排序后的字符数组转成字符串

String result = String.valueOf(chs);

//输出最后的字符串

System.out.println("result:"+result);

}


// 冒泡排序

public static void bubbleSort(char[] chs) {

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

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

if (chs[y] > chs[y + 1]) {

char temp = chs[y];

chs[y] = chs[y + 1];

chs[y + 1] = temp;

}

}

}

}

}



3:Integer(掌握)

(1)为了让基本类型的数据进行更多的操作,Java就为每种基本类型提供了对应的包装类类型

byte Byte

shortShort

intInteger

longLong

floatFloat

doubleDouble

charCharacter

booleanBoolean


/*

 * 需求1:我要求大家把100这个数据的二进制,八进制,十六进制计算出来

 * 需求2:我要求大家判断一个数据是否是int范围内的。

 * 首先你的知道int的范围是多大?

 * 

 * 为了对基本数据类型进行更多的操作,更方便的操作,Java就针对每一种基本数据类型提供了对应的类类型。包装类类型。

 * byte Byte

 * shortShort

 * intInteger

 * longLong

 * floatFloat

 * doubleDouble

 * charCharacter

 * booleanBoolean

 * 

 * 用于基本数据类型与字符串之间的转换。

 */

public class IntegerDemo {

public static void main(String[] args) {

// 不麻烦的就来了

// public static String toBinaryString(int i)

System.out.println(Integer.toBinaryString(100));

// public static String toOctalString(int i)

System.out.println(Integer.toOctalString(100));

// public static String toHexString(int i)

System.out.println(Integer.toHexString(100));


// public static final int MAX_VALUE

System.out.println(Integer.MAX_VALUE);

// public static final int MIN_VALUE

System.out.println(Integer.MIN_VALUE);

}

}



(2)Integer的构造方法

A:Integer i = new Integer(100);

B:Integer i = new Integer("100");

注意:这里的字符串必须是由数字字符组成


package cn.itcast_02;


/*

 * Integer的构造方法:

 * public Integer(int value)

 * public Integer(String s)

 * 注意:这个字符串必须是由数字字符组成

 */

public class IntegerDemo {

public static void main(String[] args) {

// 方式1

int i = 100;

Integer ii = new Integer(i);

System.out.println("ii:" + ii);


// 方式2

String s = "100";

// NumberFormatException

// String s = "abc";

Integer iii = new Integer(s);

System.out.println("iii:" + iii);

}

}



(3)String和int的相互转换

A:String -- int

Integer.parseInt("100");

B:int -- String

String.valueOf(100);


/*

 * int类型和String类型的相互转换

 * 

 * int -- String

 * String.valueOf(number)

 * 

 * String -- int

 * Integer.parseInt(s)

 */

public class IntegerDemo {

public static void main(String[] args) {

// int -- String

int number = 100;

// 方式1

String s1 = "" + number;

System.out.println("s1:" + s1);

// 方式2

String s2 = String.valueOf(number);

System.out.println("s2:" + s2);

// 方式3

// int -- Integer -- String

Integer i = new Integer(number);

String s3 = i.toString();

System.out.println("s3:" + s3);

// 方式4

// public static String toString(int i)

String s4 = Integer.toString(number);

System.out.println("s4:" + s4);

System.out.println("-----------------");


// String -- int

String s = "100";

// 方式1

// String -- Integer -- int

Integer ii = new Integer(s);

// public int intValue()

int x = ii.intValue();

System.out.println("x:" + x);

//方式2

//public static int parseInt(String s)

int y = Integer.parseInt(s);

System.out.println("y:"+y);

}

}



(4)其他的功能(了解)

进制转换


/*

 * 常用的基本进制转换

 * public static String toBinaryString(int i)

 * public static String toOctalString(int i)

 * public static String toHexString(int i)

 * 

 * 十进制到其他进制

 * public static String toString(int i,int radix)

 * 由这个我们也看到了进制的范围:2-36

 * 为什么呢?0,...9,a...z

 * 

 * 其他进制到十进制

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

 */

public class IntegerDemo {

public static void main(String[] args) {

// 十进制到二进制,八进制,十六进制

System.out.println(Integer.toBinaryString(100));

System.out.println(Integer.toOctalString(100));

System.out.println(Integer.toHexString(100));

System.out.println("-------------------------");


// 十进制到其他进制

System.out.println(Integer.toString(100, 10));

System.out.println(Integer.toString(100, 2));

System.out.println(Integer.toString(100, 8));

System.out.println(Integer.toString(100, 16));

System.out.println(Integer.toString(100, 5));

System.out.println(Integer.toString(100, 7));

System.out.println(Integer.toString(100, -7));

System.out.println(Integer.toString(100, 70));

System.out.println(Integer.toString(100, 1));

System.out.println(Integer.toString(100, 17));

System.out.println(Integer.toString(100, 32));

System.out.println(Integer.toString(100, 37));

System.out.println(Integer.toString(100, 36));

System.out.println("-------------------------");

//其他进制到十进制

System.out.println(Integer.parseInt("100", 10));

System.out.println(Integer.parseInt("100", 2));

System.out.println(Integer.parseInt("100", 8));

System.out.println(Integer.parseInt("100", 16));

System.out.println(Integer.parseInt("100", 23));

//NumberFormatException

//System.out.println(Integer.parseInt("123", 2));

}

}



(5)JDK5的新特性

自动装箱基本类型--引用类型

自动拆箱引用类型--基本类型

把下面的这个代码理解即可:

Integer i = 100;

i += 200;


/*

 * JDK5的新特性

 * 自动装箱:把基本类型转换为包装类类型    Integer类中valueof

 * 自动拆箱:把包装类类型转换为基本类型    Integer类中intValue

 * 

 * 注意一个小问题:

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

 * 建议先判断是否为null,然后再使用。

 */

public class IntegerDemo {

public static void main(String[] args) {

// 定义了一个int类型的包装类类型变量i

// Integer i = new Integer(100);

Integer ii = 100;

ii += 200;

System.out.println("ii:" + ii);


// 通过反编译后的代码

// Integer ii = Integer.valueOf(100); //自动装箱

// ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱,再自动装箱

// System.out.println((new StringBuilder("ii:")).append(ii).toString());


Integer iii = null;

// NullPointerException

if (iii != null) {

iii += 1000;

System.out.println(iii);

}

}

}

(6)面试题

-128到127之间的数据缓冲池问题

字符方法区中存在一个字节常量池


/*

 * 看程序写结果

 * 

 * 注意:Integer的数据直接赋值,如果在-128到127之间,会直接从缓冲池里获取数据

 */

public class IntegerDemo {

public static void main(String[] args) {

Integer i1 = new Integer(127);

Integer i2 = new Integer(127);

System.out.println(i1 == i2);

System.out.println(i1.equals(i2));

System.out.println("-----------");


Integer i3 = new Integer(128);

Integer i4 = new Integer(128);

System.out.println(i3 == i4);

System.out.println(i3.equals(i4));

System.out.println("-----------");


Integer i5 = 128;

Integer i6 = 128;

System.out.println(i5 == i6);

System.out.println(i5.equals(i6));

System.out.println("-----------");


Integer i7 = 127;

Integer i8 = 127;

System.out.println(i7 == i8);

System.out.println(i7.equals(i8));


// 通过查看源码,我们就知道了,针对-128到127之间的数据,做了一个数据缓冲池,如果数据是该范围内的,每次并不创建新的空间

// Integer ii = Integer.valueOf(127);

}

}




4:Character(了解)

(1)Character构造方法

Character ch = new Character('a');

/*

 * Character 类在对象中包装一个基本类型 char 的值

 * 此外,该类提供了几种方法,以确定字符的类别(小写字母,数字,等等),并将字符从大写转换成小写,反之亦然

 * 

 * 构造方法:

 * Character(char value)

 */

public class CharacterDemo {

public static void main(String[] args) {

// 创建对象

// Character ch = new Character((char) 97);

Character ch = new Character('a');

System.out.println("ch:" + ch);

}

}


(2)要掌握的方法:(自己补齐)

A:判断给定的字符是否是大写

B:判断给定的字符是否是小写

C:判断给定的字符是否是数字字符

D:把给定的字符转成大写

E:把给定的字符转成小写


/*

 * public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符

 * public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符

 * public static boolean isDigit(char ch):判断给定的字符是否是数字字符

 * public static char toUpperCase(char ch):把给定的字符转换为大写字符

 * public static char toLowerCase(char ch):把给定的字符转换为小写字符

 */

public class CharacterDemo {

public static void main(String[] args) {

// public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符

System.out.println("isUpperCase:" + Character.isUpperCase('A'));

System.out.println("isUpperCase:" + Character.isUpperCase('a'));

System.out.println("isUpperCase:" + Character.isUpperCase('0'));

System.out.println("-----------------------------------------");

// public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符

System.out.println("isLowerCase:" + Character.isLowerCase('A'));

System.out.println("isLowerCase:" + Character.isLowerCase('a'));

System.out.println("isLowerCase:" + Character.isLowerCase('0'));

System.out.println("-----------------------------------------");

// public static boolean isDigit(char ch):判断给定的字符是否是数字字符

System.out.println("isDigit:" + Character.isDigit('A'));

System.out.println("isDigit:" + Character.isDigit('a'));

System.out.println("isDigit:" + Character.isDigit('0'));

System.out.println("-----------------------------------------");

// public static char toUpperCase(char ch):把给定的字符转换为大写字符

System.out.println("toUpperCase:" + Character.toUpperCase('A'));

System.out.println("toUpperCase:" + Character.toUpperCase('a'));

System.out.println("-----------------------------------------");

// public static char toLowerCase(char ch):把给定的字符转换为小写字符

System.out.println("toLowerCase:" + Character.toLowerCase('A'));

System.out.println("toLowerCase:" + Character.toLowerCase('a'));

}

}



(3)案例:

统计字符串中大写,小写及数字字符出现的次数


import java.util.Scanner;


/*

 * 统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)

 * 

 * 分析:

 * A:定义三个统计变量。

 * int bigCont=0;

 * int smalCount=0;

 * int numberCount=0;

 * B:键盘录入一个字符串。

 * C:把字符串转换为字符数组。

 * D:遍历字符数组获取到每一个字符

 * E:判断该字符是

 * 大写bigCount++;

 * 小写smalCount++;

 * 数字numberCount++;

 * F:输出结果即可

 */

public class CharacterTest {

public static void main(String[] args) {

// 定义三个统计变量。

int bigCount = 0;

int smallCount = 0;

int numberCount = 0;


// 键盘录入一个字符串。

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个字符串:");

String line = sc.nextLine();


// 把字符串转换为字符数组。

char[] chs = line.toCharArray();


// 历字符数组获取到每一个字符

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

char ch = chs[x];


// 判断该字符

if (Character.isUpperCase(ch)) {

bigCount++;

} else if (Character.isLowerCase(ch)) {

smallCount++;

} else if (Character.isDigit(ch)) {

numberCount++;

}

}


// 输出结果即可

System.out.println("大写字母:" + bigCount + "个");

System.out.println("小写字母:" + smallCount + "个");

System.out.println("数字字符:" + numberCount + "个");

}

}


Java帮帮今日头条号



Java帮帮微信公众号



Java帮帮交流群



版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
+ 订阅

云安全开发者的大本营

其他文章
最新文章
相关文章