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; //先自动拆箱，再自动装箱