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<a.length;i++) {
String s = a[i];
//处理 s
}
----
for(String s :a) {
//处理 s
}
* 集合
for(Interator<String> it = list.iterator(); it.hasNext();) {
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()
枚举 Enumeration
* 一组固定选项
* 用来代替整数数字代码选项，
提供类型安全的选项
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> {
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，必须二选一：
*)插管道
*)捕获
io
*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
Java for Android 基础API整理相关推荐
- 最全 BAT 大厂Java和Android面试题整理！（速度收藏）
又到了面试求职高峰期,最近有很多网友都在求大厂面试题.正好我之前电脑里面有这方面的整理,于是就发上来分享给大家. 这些题目是网友去百度.小米.乐视.美团.58.猎豹.360.新浪.搜狐等一线互联网公司 ...
- 【Node】常用基础 API 整理
一.Debug 调试方法 Node 的调试方法有很多,主要分为安装 node-inspect 包调试.用 Chrome DevTools 调试和 IDE 调试,可以在官网的 Docs Debuggin ...
- Java、Android基础之—反射
前言 写这篇文章原因之一,是因为之后会对一些Android第三方框架进行分析.虽不能达到完全清晰,但大体的涉及知识需明白. 反射概述 反射是框架设计的灵魂.(使用的前提条件:必须先得到代表的字节码的C ...
- Java原理性基础知识整理[详细]
文章目录 Java程序编译过程 编译型和解析型语言 命名规范 编程风格 大括号 非C风格的数组声明 阿里巴巴Java开发手册 On Java 8 Google Java 编程风格指南 基本数据类型 整 ...
- Android 基础资料整理.
#控件属性 1. TextView的属性 属性设置 值 android:id="" 控件的id android:layout_width="" 控件的宽度 wa ...
- 一文看懂Java虚拟机——JVM基础概念整理
1 基础概念 2 垃圾回收 3 虚拟机调优
- Java期末复习基础知识整理（有点长）
平台无关: 在一个计算机上编译得到的字节码文件可以复制到任何一个安装了Java运行环境的计算机上直接使用.字节码由Java虚拟机负责解释运行,即Java虚拟机负责将字节码翻译成本地计算机的机器码,并将 ...
- Java、Android注解代码生成(ButterKnife原理、ViewBinding)
前言 首先需要一些先验知识: 浅谈Java/Android下的注解 Java.Android基础之-反射 Java.Android静态代理与动态代理 简介 在我们常用的框架中注解和自动生成代码的身影很 ...
- Java 面试/笔试题神整理 [Java web and android]
Java 面试/笔试题神整理 一.Java web 相关基础知识 1.面向对象的特征有哪些方面 1.抽象: 抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面.抽象并 ...
- java基础知识 整理
1.面向对象的特征有哪些方面? 答:面向对象的特征主要有以下几个方面: - 抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面.抽象只关注对象有哪些属性和行为,并不关注 ...
最新文章
- 深度学习（4）基础4 -- 神经网络架构激活函数过拟合处理
- day5 Python爬虫学习
- 余额宝收益冻结是什么意思？
- 字符串重复字符统计c语言,[讨论]精简字符串重复字符程序
- 如何从一个html页面调用另外一个页面的js函数,解决同一页面中两个iframe互相调用jquery,js函数的方法...
- 聚类分析在SPSS上的实现与结果分析——基于SPSS实验报告
- JAVA之MD5加密工具类
- c语言猜数字课设报告,c语言猜数字课程设计报告.doc
- 计算机程序员的英文简历,电脑程序员个人英文简历范文
- 苹果笔记本风扇测试软件,实用的mac电脑风扇控制软件 Macs Fan Control Pro
- [026] 微信公众帐号开发教程第2篇-微信公众帐号的类型（普通和会议）
- Codeforces ~ 1009C ~ Annoying Present (贪心)
- android ar 动画,Android实现支付宝AR扫描动画效果
- ubuntu 常识（转）
- 2022江苏最新八大员之（安全员）模拟考试试题及答案
- android监控app被杀死,Android App前后台监控
- 非空子集的生成（二进制法）
- 计算机右下角时间格式,电脑右下角时间格式_电脑右下角时间不准
- 美颜sdk是如何美化皮肤的？
- pythonreshape函数三个参数_Python Numpy中reshape函数参数-1的含义