Java API常见的使用类（二）
数组的高级操作
1,数组是存储同一种数据类型多个元素的容器。
2,特点是每个元素都有从0开始的编号，称为索引。
3,数据的操作：
1，遍历：
//数组的遍历 public static void printArray(int[] arr){ for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); } }
2，获取最大值：
//获取最大值 public static int getMax(int[] arr){ int max=arr[0]; for(int i=1;i<arr.length;i++){ if(arr[i]>max){ max=arr[i]; } } return max; }
3，排序：
a 冒泡排序：相邻元素两两比较，最大后往后放，第一次比较完毕，最大值在最大索引处。
//冒泡排序 public static void bubleSort(int[] arr){ for(int i=0;i<arr.length-1;i++){ for(int j=0;j<arr.length-i-1;j++){ if(arr[j]>arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } }
b 选择排序：从0索引元素开始，依次和后边的所有元素进行比较，小的往0索引处放，第一次比较完毕后，最小值在0索引。
//选择排序 public static void selectSort(int[] arr){ for(int i=0;i<arr.length-1;i++){ for(int j=i+1;j<arr.length;j++){ if(arr[i]<arr[j]){ int temp=arr[j]; arr[j]=arr[i]; arr[i]=temp; } } } }
4，查找：
a 普通查找：遍历数组，从头找到尾。
//查找 public static int getIndex(int[] arr,int value){ int index=-1; if(arr==null) return index; for(int i=0;i<arr.length;i++){ if(arr[i]==value){ index=i; break; } } return index; }
b 二分查找：每次都从中间开始查找，如比中间值小，就在左边找，如果比中间值大，就在右边找，如果相等就返回该值索引。
前提：数组必须是有序的。
public static void getIndex(int[] arr,int value){ int start=0; int end=arr.length-1; int mid=(start+end)>>1; 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)>>1; } return mid; }
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)
StringBuffer
1,StringBuffer是字符串缓冲区，长度可改变。
2,构造方法：
a：StringBuffer buffer=new StringBuffer();
b：StringBuffer buffer=new StringBuffer(int capacity);
c：StringBuffer buffer=new StringBuffer(String s);
注意： StringBuilder的功能与StringBuffer一致，StringBuilder是JDK5以后出现的。
3,需要掌握的功能：
添加功能:
StringBuffer append(data):在缓冲区追加数据，添加到尾部。
StringBuffer insert(index,data):在指定位置插入数据。
删除功能：
StringBuffer delete(start,end):删除从指定位置开始到结束的内容。包左不包右。
StringBuffer deleteCharAt(index):删除指定位置的字符。
替换功能：
StringBuffer replace(start,end,string):从指定位置开始至结束的内容替换成一个字符串，返回当前对象的引用。
截取功能：
public String substring(int start):截取从指定位置开始到末尾的字符串并返回。
public String subsring(int start,int end)截取从指定位置开始到指定位置结束的内容，并返回。
返转功能：
public StringBuffer reverse():把字符串缓冲区对象的内容进行反转。
字符串和字符缓冲区的相互转换：
// String-->StringBuffer StringBuffer buffer=new StringBuffer(String s); StringBuffer buffer=new StringBuffer(); buffer.append(String s); // StringBuffer-->String String s=new String(StringBuffer buffer); String s=(StringBuffer buffer).toStirng();
基本数据类型包装类
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=Integer.valueOf(i);
5,JDK5以后的新特性。
a 自动装箱：从int到Integer
b 自动拆箱：从Integer到int
//示例 Integer i=100; //自动装箱，等价于 Integer i=new Integer(100); i+=200; //i自动拆箱 i.intValue() //自动装箱 i=i.intValue()+200; System.out.println(i);
注意事项：基本数据类型包装类让我们操作变的简单 ，但其中也隐含一个问题，操作前最好做不为null的校验。
6,Byte常量池的问题：
//byte常量池示例 Integer i=new Integer(128); Integer i2=new Integer(128); System.out.println(i==i2); //false System.out.println(i.equals(i2)); //true Integer i3=128; Integer i4=128; System.out.println(i3==i4); //false System.out.println(i3.equals(i4)); //true Integer i5=127; Integer i6=127; System.out.println(i5==i6); //true System.out.println(i5.equals(i6)); //true Integer i7=new Integer(127); Integer i8=new Integer(127); System.out.println(i7==i8); //false System.out.println(i7.equals(i8)); //true //byte范围内的值赋值包装类的时候，是从常量池里获取的。
7,包装类的功能测试
需求：把“1 44 34 88 98 -4”字符串进行排序并打印输出
分析：
首先需要将字符串中的空格进行去除，
然后将字符串需要进行类型转换成数组。
将数组进行排序，
将数组转换成字符串，输出。
//获取字符串 String s="1 44 34 88 98 -1"; //将字符串空格切割转换成字符串数组 String[] strs=s.split(" "); //将字符串数组转成int数组 int [] arr=new int[strs.length]; for(int i=0;i<strs.length;i++){ arr[i]=Integer.parseInt(strs[i]); //对数组进行排序 Arrays.sort(arr); //调用方法 将数组转换成字符串原来的格式。 String result=strsToString(arr); System.out.println(result); // //返回类型：String //参数列表：int[] private static String strsToString(int[] arr) { StringBuilder builder=new StringBuilder(); for(int i=0;i<arr.length;i++){ builder.append(arr[i]).append(" "); } return builder.toString().trim(); }
Random
1,是产生随机数的类。
2,构造方法：
a Random r=new Random();
b Random r=new Random(long seed);
注意：种子一样，随机数一样。
3,掌握的方法 ：
public int nextInt(int n );
产生在[0,n]之间的随机数。
正则表达式
1,符合一定规则的字符串。
2,规则：
字符：
x 字符x
\\ 反斜线字符
\r 回车
\n 换行
字符类：
[abc] a、b或c
[^abc] 任何字符，除了a、b或c
[a-zA-Z] a到z,A到Z，包括两端的字符
[0-9] 数字0到9
预定义字符：
. 任意字符
\d 数字[0-9]
\w 单词字符[a-zA-Z_0-9]
边界适配器：
^ 行的开头
$ 行的结尾
\b 单词的边界 指这里不能出现的字符，如hello;world xi.xi
Greedu数量词：
x? x，一次或一次也没有。
x* x,零次或多次。
x+ x,一次或多次。
x{n} x，n次。
x{n,} x，n次以上。
x{n,m} x至少n次不超过m
组：从左边小括号开始编号，每一个对应一个组。
(a(b(c)d(e)))
第一组：a(b(c)d(e))
第二组：b(c)d(e)
第三组：c
第四组：e
我们可以通过组名来获取组内的内容，组0表示整个表达式。
组功能示例：
需求：
“我..我.爱爱....JJJ..ja...a..vv...aaa....a”将字符串还原成"我爱Java"
分析：
首先将所有.替换成“”
将重复的叠词只保留一个。
//定义一个字符串 String strs="我..我.爱爱....JJJ..Ja...a..vv...aaa....a"; //将.替换成"" String s1=strs.replaceAll("\\.",""); //将重复的叠词保留一个 String s2=s1.replaceAll("(.)\\1+","$1"); System.out.println(s2);
叠词：
在同一个字符串中，右边引用左边：“(.)\\1+”
在下一个字符串中引用前边字符串组的内容:“(.)\\1+”,“$1”
3,通过String类的功能使用正则表达式
判断 public boolean matches(String regex)
分割 public String[] split(String regex)
替换 public String replaceAll(String regex,String newString)
获取 ：
1,pattern和Matcher类。
pattern:正则表达式的编译表示形式。
Matcher:匹配器
2,使用步骤：
//正则表达式获取功能的使用步骤 Pattern p=Pattern.compile(String regex);//规则 Matcher m=p.matcher(String findstring);//查找的字符串 //判断是否有 while(m.find){ //有就获取 System.out.println(m.group()); }
3,获取的简易示例：
需求：“hi,what do you want to do?”找到其中两个字符的单 词分别是哪些
//定义一个字符串 String s="hi,what do you wat to do ?"; //定义规则 String regex="\\b[a-z]{2}\\b" Pattern p=Pattern.compile(regex); Matcher m=p.mathcer(str); while(m.find){ System.out.println(m.group()); }
Date
1,Date：是一个日期类，大部分方法已过时。被Calendar替代
构造方法 ：
Date d=new Date();//获得当前日期的毫秒值
Date d=new Date(long time);//把一个毫秒值转换成日期。
获取毫秒值:
getTime()
2,DateFormat:
对日期进行格式化和字符串进行解析的类。
String >> Date
public Date parse(String source)
解析：parse()
Date >> String
public final String format(Date date)
格式化：format()
示例：
//获得当前日期 Date d=new Date(); String s=dateToString(d,"yyyy年MM月dd日HH:mm:ss"); System.out.println(s); public static String dateToString(Date date,String format){ return new SimpleDateFormat(format).format(date); }
//字符串日期转成日期 String s="2014-03-27 15:20:13"; Date d=stringToDate(s,"yyyy-MM-dd HH:mm:ss"); System.out.println(d); private static Date stringToDate(String date,String string) throws ParseException { return new SimpleDateFormat(string).parse(date); }
3,Calendar:
日历类，对日期进行了更细的划分，可以获取日历的每个字段值。
根据日历字段获取对应的值：
get()
设置年月日
set(int year,int month,int date)
修改指定日历的值
add(int field,int value)
示例：
根据输入的日期判断这年的2月有多少天（闰年）
Calendar c=Calendar.getIntance(); Scanner sc=new Scanner(System.in); int y=sc.nextInt(); c.get(y,2,1); c.add(Calendar.DATE,-1); int d=c.get(Calendar.DATE); System.out.println(d);
System
系统类，通过静态的方法供我们使用。
需要掌握的功能：
exit()
currentTimeMillis()
arraycopy() 小写。
Collection
1,集合的由来：
我们需要对多个对象进行存储，可以使用对象数组。
但是如果对象的个数是变化的， 对象数组就解决不了。
因此Java提供了集合类。
2,集合体系的由来：
多种集合的数据结构不同，但是它们都有共同的特性，
通过不断的向上抽取，最终形成了集合的体系结构。
Collection
|
|-----List
|---ArrayList
|---Vactor
|---LinkedList
|
|-----Set
|---HashSet
|---TreeSet
3,Collection的接口功能：
添加功能：add(Object obj)
删除功能：remove(Object obj)
判断功能：contains(Object obj)
获取功能：Iterator iterator()
长度功能：size()
4,迭代器：以内部类的方式存在。
1,就是遍历集合的一种方式。
2,迭代器不能单独使用，它依赖集合而存在。
3,使用步骤：
1,通过集合调用Iterator的方法得到迭代器对象。
2,通过迭代器的hasNext()判断是否有元素。
3,通过迭代器的next()方法获取元素。
集合示例：
//创建集合对象 Collection c=new ArrayList(); //创建元素对象 String s="hello"; String s1="world"; String s2="java"; //将元素添加到集合 c.add(s); c.add(s1); c.add(s2); //通过集合调用Iterator()方法获得迭代器对象 Iterator it=c.iterator(); //遍历 while(it.hasNext()){ //向下转型 String s=(String)it.next(); System.out.println(s); }
