java api 有多少个类_Java API常见的使用类（二）

数组的高级操作

1,数组是存储同一种数据类型多个元素的容器。

2,特点是每个元素都有从0开始的编号，称为索引。

3,数据的操作：

1，遍历：

//数组的遍历

public static void printArray(int[] arr){for(int i=0;i

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

}

}

2，获取最大值：

//获取最大值

public static int getMax(int[] arr){int max=arr[0];for(int i=1;imax){

max=arr[i];

}

}returnmax;

}

3，排序：

a 冒泡排序：相邻元素两两比较，最大后往后放，第一次比较完毕，最大值在最大索引处。

//冒泡排序

public static void bubleSort(int[] arr){for(int i=0;iarr[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[j]=arr[i];

arr[i]=temp;

}

}

}

}

4，查找：

a 普通查找：遍历数组，从头找到尾。

//查找

public static int getIndex(int[] arr,intvalue){int index=-1;if(arr==null) returnindex;for(int i=0;i

index=i;break;

}

}returnindex;

}

b 二分查找：每次都从中间开始查找，如比中间值小，就在左边找，如果比中间值大，就在右边找，如果相等就返回该值索引。

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

public static void getIndex(int[] arr,intvalue){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

end=mid-1;

}if(start>end){return -1;

}

mid=(start+end)>>1;

}returnmid;

}

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=newStringBuffer(String s);

StringBuffer buffer=newStringBuffer();

buffer.append(String s);//StringBuffer-->String

String s=newString(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)); //trueInteger i3=128;

Integer i4=128;

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

System.out.println(i3.equals(i4)); //trueInteger i5=127;

Integer i6=127;

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

System.out.println(i5.equals(i6)); //trueInteger 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

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=newStringBuilder();for(int i=0;i

builder.append(arr[i]).append(" ");

}returnbuilder.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=newDate();

String s=dateToString(d,"yyyy年MM月dd日HH:mm:ss");

System.out.println(s);public staticString dateToString(Date date,String format){return newSimpleDateFormat(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) throwsParseException {return newSimpleDateFormat(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=newScanner(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=newArrayList();//创建元素对象

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);

}