Java for Android 基础API整理
API简析
*application programming interface 应用编程接口
*一切能调用的东西
Java.lang包
Lang=language
语言包
自动导包
String
System
Integer
Java.lang.object
Java.lang.String
Java.lang.stringBuilder
Java.lang.StringBuffer
正则表达式
Java.util.regex.pattern
Java.util.regex.Matcher
基本类型包装类
Java.math.BigDecimal
Java.math.BigInteger
Java.text.DecimalFormat
Java.lang.Math
Java.util.data
Java.text.SimpleDtaFormat
Java.util.Calender
Java.util.GregorianCalendar
Java.lang.Object
*java的顶层父类
*一个类如果不继承其他类
默认继承Object
ClassA /*entends Object*/{
}
方法：
toString()
获得对象的字符串表示
默认实现是
abcdef.day1301.Point@a123kjl
“类型名称@内存地址”
如果需要，可以在子类中重写这个方法
equals(Objectobj)
当前对象与参数对象obj比较是否相等
a.equals(b)
Object中默认实现是：
比较对象的内存地址
This == obj
提示：
学号和年龄是int基本类型，用 == 比较
姓名和性别是String类型，用equals()比较
基本类型 == 表示值比较
String 类型 == 地址比较
Object类中 == equals 都表示储存的对象的地址比较 只是equals在很多类中进行了重写
在string中，先进行地址比较再进行值比较 可理解为值的比较
Java.lang.String
*封装char[]数组的对象
*字符串的字面值
*第一次使用一个字面值时
在“字符串常量池”中新分配内存创建字符串对象
*再次使用相同字面值时
直接访问“常量池”中存在的对象，而不会新建
*字符串不可变
创建对象
1. byte[] a = {‘h’,’e’,’l’,’l’,’o’};
String s = new String(a);
2. 第一种创建方式的语法简化
String s = “hello”;
方法
CharAt(intindex)获得指定位置字符
S= “abc”;
CharC = s.charAt(2);
ToUpperCase()变成大写
S= s.toUpperCase()
Print(s);
toLowerCase()变成小写
length()长度
compareTo(Sting,anotherString)
compareTolgnoreCase(Stringstr)忽略大小写与另一字符串按编码表顺序比较大小
当前字符串大，返回整数
当前字符串小，返回负数
大小相同，返回0
startsWith(Strings) 是否以指定的子串开头或结尾
s= "http://www.163.com"
booleanb = s.startsWith("http://")
endsWith(Stringsuffix)
equals(ObjectanObject)
equalsIgnoreCase(StringanotherString)
忽略大小写，比较字符串内容是否相同
indexOf(Strings, int fromIndex) 从指定位置向后寻找，获得指定子串的位置，不存在，返回 -1
lastIndexOf(Strings) 从后向前寻找子串的位置
indexOf(Strings)
s= "abc abc abc";
intindex = s.lastIndexOf("xxxxx");
replace(charoldChar, char newChar)将指定的字符替换为新的字符 s= "abc abc abc";
Strings2 = s.replace('a', '-');
System.out.println(s2);
substring(int a) 从 a 位置直到结束
s= "abcdefg";
Strring s2 = s.substring(3, 5);
System.out.println(s2);
substring(int a, int b) 获得 [a, b) 位置范围的子串
trim() 去除两端空白字符
s= " a bc ";
s= s.trim();
System.out.println(s);
getBytes() unicode 转为默认编码格式的字节数组
getBytes(字符编码) 将 unicode 转为指定编码格式的字节数组
String.valueOf(数据) 将任何数据转为字符串
publicclass Test3 {
publicstaticvoid main(String[] args) {
Strings = "abc abc abc ";
System.out.println(s);
System.out.println("1位置字符:"+s.charAt(1));
System.out.println("2位置字符:"+s.charAt(2));
System.out.println("变大写:"+s.toUpperCase());
System.out.println("变小写:"+s.toLowerCase());
System.out.println("长度:"+s.length());
System.out.println("与xyz比大小:"+s.compareTo(" xyz"));
System.out.println("是否以abc开头:"+s.startsWith(" abc"));
System.out.println("是否以bc结尾:"+s.endsWith("bc "));
System.out.println("第一个bc的位置:"+s.indexOf("bc"));
System.out.println("3位置向后找bc:"+s.indexOf("bc",3));
System.out.println("从后向前找bc:"+s.lastIndexOf("bc"));
System.out.println("找不存在的子串:"+s.indexOf("xxxx"));
System.out.println("a替换成-:"+s.replace('a','-'));
System.out.println("截取6到末尾:"+s.substring(6));
System.out.println("截取[6,10]:"+s.substring(6,10));
System.out.println("去除两端空格:"+s.trim());
}
}
运行结果：
abc abc abc
1位置字符:b
2位置字符:c
变大写:ABC ABC ABC
变小写:abc abc abc
长度:12
与xyz比大小:65
是否以abc开头:false
是否以bc结尾:true
第一个bc的位置:1
3位置向后找bc:5
从后向前找bc:9
找不存在的子串:-1
a替换成-:-bc-bc -bc
截取6到末尾:c abc
截取[6,10]:c ab
去除两端空格:abc abc abc
Java.lang.StringBuilder Java.lang.StringBuffer
*可变的字符序列
*封装char[]数组对象
*用来代替字符串做高效率的字符串连接
sb.append(“abc”);
创建对象
1.无参数StringBuilder sb = StringBuilder();
2.带参数StringBuilder sb = StringBuilder(“abc”);
正则表达式 Regex
*正确的字符串格式规则 (百度“正则表达式大全”)
s.matches()是否匹配
正则表达式 匹配的字符串
K k
Abc abc
[abc] a,b,c
[abc][123] a1,a2,a3,b1,b2,b3…
[^a-zA-Z] 排除字母
\d 数字
\D 排除数字
\w 单词字符[a-zA-Z_0-9]
\W 排除单词字符
\s 空白字符
\S 排除空白字符
. 任意字符
[\u4e00-\u9fa5] 中文范围
[abc]? 0或1个 a,b,,c,
[abc]?[123] a1,b2,3,2,1
[abc]* 0到多个
[abc]+ 1到多个a,b,aacccbb…
[abc]{3} aaa,abc,bbb,acc
[abc]{3,5} abc,abcaa,abcc
[abc]{3,} 3到多个
| 或
replaceAll(正则表达式, 子串)
将找到的匹配子串，替换为新的子串
split(正则表达式)
用匹配的子串，拆分字符串
abc,def,ghi,jkl
Java.util.regex.Pattern Java.util.regex.Matcher
*Pattern封装一个正则表达式
*Matcher封装正则表达式和要匹配的字符串
创建对象
Pattern p = Pattern.compile(正则表达式);
Matcherm = p.matcher(要匹配的字符串);
Matcher方法
Find
向后查找下一段匹配的子串
找到返回true
找不到返回false
Find(intfrom)
从from位置向后查找
Group()
取出刚刚找到的子串
Start()
End()
取出刚刚找到的子串的起始位置和结束位置
End位置不包含（左闭右开）
基本类型包装类
byte Byte
short Short
int Interger
long Long
float Float
double Double
char Character
boolean Boolean
java.lang.Number
*数字包装类的抽象类
*子类：
Byte
Short
Integer
Long
Float
Double
BigDecimal
BigInteger
方法
从包装对象中取出被封装的基本类型值
bytevlaue
shortValue
intVlaue
longValue
floatValue
longValue
floatValue
doubleValue
java.lang.Integer
创建对象
1.IntergerI = new integer(10);
2.IntegerI = Integer.valueOf(10);
在Integer类中存在-128到127
共256个Integer缓存对象
指定范围内的值，直接访问存在的缓存对象
指定范围外的值，新建对象
方法
*从父类Number继承的6个取值方法
*字符串解析成int
Integer.parseInt(“255”);
Integer.parseInt(“11111111”,2);指定2进制
Integer.parseInt(“377”,8); 指定8进制
Integer.parseInt(“ff”,16); 指定16进制
*进制转换
Integer.toBinaryString(255); 1111111 二进制
Integer.toOctalString(255); 377 八进制
Integer.toHexString(255); ff 十六进制
Java.lang.Double
创建对象
1. Double d = new Double(3.14);
2. Double d = Double.valueOf(3.14);
与new相同，都是新建对象
方法
*）从父类继承的6个取值方法
*）字符串解析成double
Double.parseDouble(“3.14”);
Inter.paeseInt()
Long.parseLong()
Short.parseShort()
Boolean.parseBoolean()
*)判断double的两个特殊值 返回true flase
Infinity
Double.isInfinite(doubled); 判断是否无穷大
NaN
Double.isNaN(Doubled); 判断是否是NaN
*自动装箱、自动拆箱
*）自动装箱
Integeri = 34;
编译成：Integer i= Integer.valueOf(34);
封装34对象 把内存地址赋给i
*）自动拆箱
Inta = i;
编译成：int a =i.intValue();
i= i + 3;
编译成：i =Integer.valueOf(i.intValue()+3);
*自动拆箱要当心null值
Java.math.BigDecimal Java.math.BigInteger
*BigDecimal做精确的浮点数云端
*BigInteger 做超大整数运算
创建对象
BigDecimal bd = BigDecimal.valueOf(2);
方法
Add(BigDecimalbd)
subtract(BigDecimalbd)
multiply(BigDecimalbd)
divide(BigDecimalbd) 不支持无限循环小数
divide(BigDecimalbg,保留位数，舍入方式)
eg：bd3 =bd1.divide(bd2,15,BigDecimal.ROUND_HALF_UP);
舍入运算：
setScal(保留位数，舍入方式)
取值：
*）从父类Number继承的6个取值方法
*）toString（）
Java.text.DecimalFormat
*数字格式工具
*数字-->数字格式的字符串
*数字格式的字符串-->数字
创建对象：
DecimalFormatf = new DecimalFormat(格式);
格式：
“$###,###.000”
“\u00A4###,###.000”当地货币
参考DecimalFormat文档
方法：
Format（数字）
数字格式化成字符串
Parse（字符串）
字符串解析成数字
Setpattern（格式）
修改格式
Java.lang.Math
Math.PI
Math.E
Math.random()
Math.sqrt()
Math.pow(a,b)
Math.min()
Math.max()
Math.sin()
Math.cos()
Math.tan()
Java.util.Date
*封装一个毫秒值
毫秒值：1970-1-10点开始的毫秒值
*表示一个时间点
创建对象
1. Date d = new Date();
封装系统当前时间毫秒值
2. Date d = newDate(90000000000000L);
封装指定的毫秒值
方法：
getTime()
setTime(Longt)
存取内部封装的毫秒值
compareTo(Dated)
当前Date对象与参数Date对象比较大小
如果当前对象大，返回整数
当前对象小，返回负数
相同，0
Java.text.SimpleDateFormat
*日期格式工具
*date对象à日期格式字符串
*日期格式字符串àdate对象
创建对象
SimpleDateFormatf = new SimpleSateFormat(格式)
格式：
“yyyy-MM-ddHH:mm:ss”
“dd/MM/yyyy”
“yy-M-dH:m”
“yyyy年MM月dd日 HH:mm:ss”
方法
Format(Date对象)
Date对象格式化成字符串
Parse(字符串)
字符串解析成date对象
SetPattern(格式)
修改格式
Java.util.Calendar
*日历的抽象父类
*内部封装一个毫秒值
*Calendar提供一组时间运算方法
创建对象
1.Calendarc = new GregorianCalendar();
2.Calendarc = Calendar.getInstance();
根据系统地区设置，可能会创建不同地区的当地历法
方法：
Get(字段)
获取指定字段的值，例如：
C.get(Calendar.YEAR)
c.get(Calendar.HOUR_OF_DAY)
set(字段)
修改指定字段值
getTime()
获得表示相同时间的Date类型实例
SetTime()
将时间设置为指定Date实例所表示的时间
Java.util.GregorianCalendar
*日历子类
*罗马历，即“公历”、“阳历”
集合
*数据结构工具
*用来存放一组数据
java.util 包
---------------------------
Collection 接口
|- List 接口
|- ArrayList
|- LinkedList
|- Set 接口
|- HashSet
|- TreeSet
Map 接口
|- HashMap
|- TreeMap
Iterator 接口
Collections 工具类
java.util.LinkedList
* 双向链表
* 两端效率高
创建对象
---------------------------------
LinkedList list = new LinkedList();
方法
---------------------------------
add(数据) 添加数据
add(int index, 数据) 在指定位置插入数据
addFirst(数据)
addLast(数据)
getFirst()
getLast()
removeFirst()
removeLast()
FIFO 操作 First InFirst Out，队列操作 Queue
offer(数据) - addLast
peek() - getFirst
poll() -removeFist
LIFO 操作 Last InFisrt Out，栈操作 Stack
push() - addFirst
pop() -removeFirst
get(int index) - 获得指定位置的值
contains(数据) - 判断列表中是否存在与指定数据相等(equals)的值
set(int index, 数据) - 将指定位置设置为新的值
size() -获得列表中数据的数量
remove(int index) - 移除指定位置的元素，并返回被移除的数据
remove(数据) - 移除与指定数据相等的数据
clear() -清空
iterator() - 获得新建的迭代器实例
java.util.ArrayList
============================================
* 内部封装一个数组，数据保存在数组中
* 访问任意位置，效率高
* 添加、删除数据，效率可能会降低
* ArrayList vs LinkedList
*)如果只在两端操作数据，选择LinkedList
创建对象
------------------------------------
1.ArrayList list = new ArrayList();
内部数组初始容量 10
2.ArrayList list = new ArrayList(1000);
内部数组初始容量 1000
方法
------------------------------------
与 LinkedList 相同，但是没有两端操作数据的方法
java.util.HashMap
* 哈希表，散列表
* 存放“键值对”数据
* 用来快速查找数据
* 键：
*)不重复
*)无序
*)必须重写 hashCode() 和 equals()
*)equals()相等，hashCode()必须相同
*)equals()不相等，hashCode()尽量不相同
创建对象
------------------------------------
HashMap map = new HashMap();
方法
------------------------------------
put(k, v) 放入键值对数据
get(k) 用键获得对应的值
remove(k) 移除指定的键和它的值
containsKey(key) 是否包含指定的键
containsValue(value)是否包含指定的值
size() 有多少对数据
clear() 清空
keySet() 获得一个 Set 类型集合，包含所有的键
entrySet() 获得一个 Set 类型结合，包含所有Entry
values() 获得集合，包含所有的值
java.util.TreeMap
* 红黑二叉树
* 用来快速查找数据
* 键：
*)不重复
*)有序，从小到大
*)比较大小的两种方式
*)键实现 Comparable 接口
*)在 TreeMap 上外接比较器Comparator(优先)
创建对象
---------------------------------------
1. TreeMap map = new TreeMap();
2. TreeMap map = new TreeMap(比较器);
方法
---------------------------------------
* 与 HashMap 相同
|- Set 接口
|- HashSet
|- TreeSet
==========================================
* HashSet 内部封装一个 HashMap,
数据作为键，存放在 HashMap 中
*)不重复、无序
* TreeSet 内部封装一个 TreeMap,
数据作为键，存放在 TreeMap 中
*)不重复、有序,从小到大
创建对象
----------------------------------
HashSet set = new HashSet();
TreeSet set = new TreeSet();
TreeSet set = new TreeSet(比较器);
方法
----------------------------------
add(数据)
remove(数据)
contains(数据)
clear()
size()
iterator()
Java.util.TreeMap
*红黑二叉树
*用来快速查找数据
*键：
*不重复
*有序，从小到大
*比较大小的两种方式
*让键实现Comparable接口
*在TreeMap上外接比较器Comparator
创建对象
1. TreeMap map = new TreeMap
2. TreeMap map = new TreeMap(比较器)；
方法
*与HashMap相同
Set接口 -Hashset -Treeset
*hashSet内部封装一个HashMap，数据作为键，存放在HashMap中
*数据不重复，无序
*TreeSet内部封装一个TreeMap，数据作为键存放在TreeMap中
*不重复、有顺序从小到大
创建对象：
HashSet set = new HashSet();
TreeSet set = new TreeSet();
TreeSet set = new TreeSet(比较器);
for-each 循环
* 对数组遍历或集合迭代器遍历的语法简化
* 数组
for(int i=0;i String s = a[i]; //处理 s } ---- for(String s :a) { //处理 s } * 集合 for(Interator String s = it.next(); //处理 s } ---- for(String s:list) { //处理 s } * 数组参数传递的语法简化 void f(int[] a) { } f(new int[]{9, 5, 2, 7}) f(new int[]{9, 5, 2, 7, 1, 2, 3, 4, 5}) f(new int[]{9, 5}) f(new int[]{}) -------------------------- void f(int... a) { //a是 int[] 数组 } f(9, 5, 2, 7) f(9, 5, 2, 7, 1, 2, 3, 4, 5) f(9, 5) f() * 一组固定选项 * 用来代替整数数字代码选项， 提供类型安全的选项 int TYPE_COLD=4343; int TYPE_HEAT=5345; int TYPE_NUCLEAR=26345; ... void f(int type) { } ... f(Weapon.TYPE_COLD) f(Weapon.TYPE_HEAT) f(Weapon.TYPE_NUCLEAR) f(234234) ------------------------ public enum WeaponType { COLD, HEAT, NUCLEAR } * 枚举本质就是一个类 * 其中的枚举选项，是WeaponType 对象 public static final WeaponType COLD=new WeaponType(); *void f(WeaponType type) { } ... f(WeaponType.COLD) f(WeaponType.HEAT) f(WeaponType.NUCLEAR) * 是一种类型参数 class A Type t; void f(Type t) { } Type f() { } } *封装错误信息的对象 错误信息： *）类型名称 *）提示消息 *）行号 * 继承结构 Throwable |- Error 系统级错误 |- Exception 可修复的错误 |- 其他Exception |- RuntimeException |- NullPointerException |-ArrayIndexOutOfBoundsException |- ArithmeticException |- NumberFormatException |- ClassCastException |- InputMismatchException ... * 捕获异常 try { ... } catch(AException e) { } catch(BException e) { } catch(父类型Exception e) { } finally { } *throws *)设置异常抛出管道 void f() throws A,B,C,D { } *)RuntimeException 存在默认抛出管道 *)其他Exception，必须二选一： *)插管道 *)捕获 *Input / Output 输入 / 输出 *java.io 包 File RandomAccessFile InputStream / OutputStream FileInputStream / FileOutputStream BufferedInputStream / BufferedOutputStream DataInputStream / DataOutputStream PrintStream ByteArrayInputStream / ByteArrayOutputStream ObjectInputStream / ObjectOutputStream Reader / Writer InputStreamReader / OutputStreamWriter FileReader / FileWriter BufferedReader / BufferedWriter PrintWriter 可变长参数
枚举 Enumeration
泛型
异常
io