java基础13

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++) {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;}}}}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)Arrays工具类的源码。

3:StringBuffer类
(1)StringBuffer:是字符串缓冲区类，长度可以改变。
(2)面试题：
String和StringBuffer的区别?
String的长度固定。
StringBuffer的长度可变。
StringBuffer和StringBuilder的区别?
StringBuffer的线程安全,效率低。
StringBuilder的线程不安去,效率高。
(3)StringBuffer的构造方法
A:StringBuffer sb = new StringBuffer();//默认容量16
B:StringBuffer sb = new StringBuffer(int capacity);//给定容量
C:StringBuffer sb = new StringBuffer(String s);//字符串长度+默认容量
注意：StringBuilder的功能和StringBuffer一模一样。前者是JDK5以后出现的。
(4)要掌握的功能：(请自己把对应的方法写出来)
A:添加功能
public StringBuffer append(String str);
public StringBuffer insert(int offset,String str)
B:删除功能
public StringBuffer delete(int start,int end)
public StringBuffer deleteCharAt(int index)
C:其他功能
替换功能
public StringBuffer replace(int start,int end,String str)
截取功能
public String substring(int index);
public String substring(int start,int end)
反转功能
public StringBuffer reverse()
(5)案例：
把一个字符串反转。

import java.util.Arrays;/* * 对字符串中字符进行自然顺序排序 * "basckd" -- "abcdks" *  * 思路： * A:定义一个字符串。 * B:把字符串转换成字符数组。 * C:对字符数组进行排序 * D:把字符数组转换成字符串。 * E:输出转换后的字符串。 */public class StringTest {public static void main(String[] args) {// 定义一个字符串。String s = "basckd";// 把字符串转换成字符数组。char[] chs = s.toCharArray();// 对字符数组进行排序// bubbleSort(chs);Arrays.sort(chs); // 开发用// 把字符数组转换成字符串。/* * 1:构造方法 2:copyValueOf 3:valueOf */String result = String.valueOf(chs);// 输出转换后的字符串。System.out.println(result);}// 面试用public static void bubbleSort(char[] 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]) {char temp = arr[y];arr[y] = arr[y + 1];arr[y + 1] = temp;}}}}}

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的功能
A:String -- int
String s = "100";
int i = Integer.parseInt(s);


B:int -- String
int i = 100;
String s = String.valueOf(i);
(5)JDK5以后的新特性
A:自动装箱 从int--Integer
B:自动拆箱 从Integer--int


请大家解释下面的代码：哪里体现了自动装箱，哪里体现了自动拆箱
Integer i = 100;//自动装箱 等价于Integer i=new Integer(100);
i += 200; //i+200 自动拆箱i.intValue(),转换成基本数据类型运算，运算成功在自动装箱赋值给i
System.out.println(i);

注意：
让我们操作变得简单，但是隐含了一个问题，这个时候，我们在使用对象前，最好做不为空的校验。
(6)面试题：(看代码 IntegerTest.java)

byte常量池。自从有了自动装箱以后，在byte 范围内的数据赋值给包装类时可以直接从byte常量池里获取

/* * 面试题：byte常量池。 * 自从有了自动装箱后，在byte范围内的值直接赋值给包装类的时候，是从常量池里获取的。 */public class IntegerTest {public static void main(String[] args) {Integer i1 = new Integer(127);Integer i2 = new Integer(127);System.out.println(i1 == i2);// falseSystem.out.println(i1.equals(i2));// trueInteger i3 = new Integer(128);Integer i4 = new Integer(128);System.out.println(i3 == i4);// falseSystem.out.println(i3.equals(i4)); // trueInteger i5 = 127;Integer i6 = 127;System.out.println(i5 == i6); // ??? -- trueSystem.out.println(i5.equals(i6));// trueInteger i7 = 128;Integer i8 = 128;System.out.println(i7 == i8); // ??? --falseSystem.out.println(i7.equals(i8)); // true}}

(7)案例：
把字符串"-34 29 76 11 27"中的数据排序并输出。
思路：定义字符串
     将字符串分割为字符串数组
     定义int类型的数组，使用包装类将对应的字符串转换为int类型的元素，赋值给对应的int数组元素
     对int类型数组排序，可自定义方法，可使用Arrays工具类

     将int数组元素转换为字符串，使用StringBuilder类的append()方法

import java.util.Arrays;/* * 需求： * 我有这样的一个字符串"34 -12 56 93 27" *              请想办法实现把字符串中的数据进行排序。 * 举例： *    有： "34 -12 56 93 27" *  结果："-12 27 34 56 93" *  * 思路：   * A:定义一个字符串 * B:把字符串按照空格进行分割得到一个字符串数组 * C:把字符串数组转成成int数组 * D:对int数组排序 * E:在把排序后的int数组转换成String *  *  */public class StringTest {public static void main(String[] args) {//定义一个字符串String s = "34 -12 56 93 27";//把字符串按照空格进行分割得到一个字符串数组String[] strArray = s.split(" ");//把字符串数组转成成int数组int[] arr = new int[strArray.length];for(int x=0; x<arr.length; x++) {arr[x] = Integer.parseInt(strArray[x]);}//对int数组排序Arrays.sort(arr);//在把排序后的int数组转换成String//StringBuilder builder = new StringBuilder();//for(int x=0; x<arr.length; x++) {//builder.append(arr[x]).append(" ");//}//String result = builder.toString().trim();//调用功能String result = arrayToString(arr);System.out.println(result);}/* * 返回值类型：String * 参数类别：int[] arr */public static String arrayToString(int[] arr) {StringBuilder builder = new StringBuilder();for(int x=0; x<arr.length; x++) {builder.append(arr[x]).append(" ");}return builder.toString().trim();}}

5:Random(理解)
(1)是产生随机数的类。
(2)构造方法：
A:Random r = new Random();
B:random r = new Random(long seed);


注意：种子一样，随机数一样。
(3)掌握的方法：

public int nextInt(int n):产生在[0,n)之间的随机数。

import java.util.Random;/* * Random:是产生随机数的类。跟种子相关。 *  * 构造方法： * Random():没有给种子产生随机数,默认种子是当前时间的毫秒值。 *Random(long seed)：给定种子产生随机数。如果种子相同，那么， 将产生相同的随机数。 * * 要掌握的功能： * public int nextInt()：int范围内的随机数。 * public int nextInt(int n)：获取的是[0,n)之间的随机数。 */public class RandomDemo {public static void main(String[] args) {// 不给种子// Random r = new Random();// 给种子Random r = new Random(250);// 表示我要生成10个[0,100)之间的随机数for (int x = 0; x < 10; x++) {System.out.println(r.nextInt(100));}}}