本帖最后由 小石姐姐 于 2018-4-20 09:14 编辑
Object,System,日期,包装类,Object类
String toString()源代码: return getClass().getName()+"@"+Integer.toHexString(hashCode());
getClass():返回一个字节码对象
Integer.toHexString:返回指定参数的十六进制字符串形式
hashCode():返回该对象的哈希码值(内部地址)
重写toString方法:快捷键 Ctrl + Shift + s → Generate toString()... Object的equals方法- boolean equals(Object obj)
获取字节码对象的3种方式方式 1示例:Class clazz= student.getClass(); 方式 2通过类名调用.Class属性来获取 示例:Class clazz = Student.class;(后面的class c小写) 扩展:实际上.Class是一种特殊形式,称为类字面常量,Class是关键字不能作为属性名,且Object类中并没有定义这个属性 方式 3通过Class类的静态方法:forName(String className)来获取 示例 :Class clazz = Class。forName ("come.itheima.Student"); 注意:因为该方法使用字符串来寻找类,有可能并没有该字符串对应的类,所以会抛出ClassNotFoundException类无法找到的异常
//创建Student对象
Student s1 = new Student();
//对象s1去调用
Class clazz1 = s1.getClass();
//类名Student调用
Class clazz2 = Student.class;
//方法调用Class.forName
Class clazz3 = Class.forName("上课01.Student");
//对比是否一样
System.out.println(clazz1 == clazz2);
System.out.println(clazz1 == clazz3);
System.out.println(clazz2 == clazz3);注意: 同一个类的字节码对象只有一个,地址值是相同的 System类常用静态方法(复制数组)
static void arrayCopy(Object src,int srcPos,Object dest, int destPos, int length);
复制源数组中指定长度个元素到一个新数组中 复制数组- static void arraycopy (Object src,int srcPos,Object dest, int destPos, int length)
src :源数组 (从那个数字中读取数据,就传入那个数组)(被复制的数组) srcPos :指定从哪个索引位置开始复制(如果给0 ,那就从0 后面的元素全部复制) dest :目标数组(这是从源数组复制到一个新的数组中(目标数组))(要复制到的数组) destPos :指定目标数组接受元素的索引位置(想从那个索引开始,就写成那个索引) length :目标数组接受元素的个数(新数组接受几个,就写几) (要复制的元素个数)
返回当前系统时间终止虚拟机的运行System类的其他方法static long currentTimeMillis()方法- static long currentTimeMillis():返回当前系统(以毫秒值返回当前系统时间)
1000毫秒 = 1秒 如果系统时间1970 - 1 - 1 0 :0:1 1000(如果是一秒,就返回1000毫秒) 如果系统时间1970 - 1 - 1 0 :1:0 1000 * 60(如果是一分钟,就返回1000*60) 如果是一小时一分钟:1000 * 60 * 60 + 1000 * 60
例题 ↓ long now = System . currentTimeMillis(); syso( now ); - static void exit (int status):终止虚拟机的运行(不是零就表示异常终止,零表示正常终止 )
- System . exit (0); (直接输入)(比如全名有个if判断,一个数 == 多少的时候,就终止虚拟机的运行(也就是终止程序的运行))
- Data :表示特定的瞬间,精确到毫秒,他可以通过方法来设定自己所表示的时间,可以表示任意的时间
- static long currentTimeMillis():返回当前系统(1970-1-1到至今的毫秒数)
数组Date类的概述和构造构造方法
Date():创建Date对象,并表示当前系统时间的Date对象
Date(long timestamo):根据指定的时间,创建Date对象成员方法String toLocalString():转换为本地时间格式的字符串 Date类的常用方法成员方法void setTime(long time):设置Date对象的时间 long gettime():获取Date对象中保存的时间毫秒值 常用方法毫秒值 ---- Date(毫秒值转成Date对象)设置 返回值是void,参数类型 long 第一种方法 void setTime ( long time (1970-1-1加上你给的值,比如1000或者 1000*60) ) 要以毫秒的形式填入 第二种方法Date(long date); toLocaleString() :这是在控制台显示时间,前面要有变量 比如 d.toLocaleString() Date d = new Date(); 括号里什么也没写,就是当前时间(前提需要导入java . util .Date;包,里面写了参数就是从1970-1-1,到你写的数值(注意是毫秒)) Date --- 毫秒值(Date对象转成毫秒值)SimpleDateFormat的概述构造方法 SilmpleDateFormat():使用默认的格式进行对象的构建 SilmpleDateFormat(String pattern):创建对象同时指定格式 成员方法格式化: Date ------→ String 日期变成字符串 2018-4-9 ------→ 2018年4月9日 字符y年 M月 m分 D年中的天 d:月中的天 H:小时(24时制) k:小时(12时制) S:毫秒 s:秒 E:星期 示例 yyy-MM-dd 2018-04-09 Calendar:日历提供了一些操作年月日时的方法 创建对象:Calendar c = Calendar.getInstance(); 方法获取 get修改 set添加 add静态字段: static YEAY:年份 static MONTH:月份,注意月份数值时0-11 static DAY_OF_MONTH:日期 static H 成员方法 int get :返回给定体力字段的值 包装类的概述和基本使用包装类- 封装了基本数据类型的类,提供了更多的方法和变量
- 把基本数据类型的使用方式转换为面对对象的使用方式
- 基本数据类型和引用数据类型的对应关系
byte: Byte long :Long short:Short float :Float char:Character double:Double int : Integer boolean:Boolean
Integer类的转换方法String ------> int 方式一:int intValue(); 方式二:String int parseInt(String s) 例题: int 变量 = 类名.psrseLnt(“10”) int ------> String 方式一:加 双引号 “ ” 方式二:String toString(); 构造方法integer(int value);int转integer integer(String s);String转integer 自动装箱基本数据类型可以自动转换为包装类 integer i = 10;这就是自动装箱 int a = i; 这是自动拆箱
自动拆箱包装类可以自动转换为基本数据类型 int a = i.intValue();
自动装箱拆箱的应用场景正则表达式Pattern类(API查看)创建正则表达式模板,内有正则表达式规则 常用规则字符 x : 一个字符x \\ :表示\反斜杠. Greedy数量次(API查看)判断字符串中间的字符是否是元音字母(aeiou)String类
boolean类型接受 = 变量名.matches (String regex):是否匹配指定的正则
String [ ] split (String regex):按照正则表达式分割字符串(按逗号分割那个)转义:转移使用 \ ,正则中有的 常用规则(查看API中的Pattern类)
切割字符串类名.split(“ 逗号或者空格等等,多个相同的,例如空格加 + ”); Collection< E >接口常用的功能(单列集合体系的顶层) 集合的体系结构由于不同的数据结构(数据的组织,储存方式),所以就有了Collection 常用方法(boolean)增加元素: add (boolean)删除元素:remove 清空元素:clear (boolean)判断集合中是否包含指定元素 contains(boolean)判断是否为空 isEmpty 返回集合中元素个数 size将集合转换成一个Object类型的数组 Object [ ] 数组名 = 集合名.toArray 获取集合的迭代器 :iterator List接口是Collection的子接口 (有序,可重复,有索引) 增 add 删 remove 改 set 查 get Listiterator:获取List特有的迭代器对象 ArrayList ArrayList类(底层是数组,查询快,增删慢) LinkedList LinkedList类(底层是链表,查询慢,增删快) addFirst:添加到元素开头 addLast:添加到元素末尾 增 删 改 查 后面加First 是开头 后面加Last是末尾 迭代器创建对象 : Collection c = new ArrayList();子类指向父类,多态 需要导包:import java.util.Iterator; iterator接口 iterator:获取List特有的迭代器对象,可以用来遍历集合 next:返回下一个元素 remove:从迭代器指向collection中移除迭代器返回的最后一个元素 hasNext:判断是否有元素获取(使用while循环) 并发修改异常 错误:ConcurrenModificationException 发生原因迭代器依赖于集合,相当于集合的一个副本,当迭代器在操作的时候,发现和集合不一样,则抛开异常 解决方案在使用迭代器遍历的时候使用迭代器修改 List接口中 ListIterator 获取与List的迭代器,然后调用ListIterator 的add方法 //创建List对象,子类指向父类
List list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("java");
//把List对象转为ListIterator迭代器
ListIterator i = list.listIterator();
//循环遍历迭代器
while (i.hasNext()) {
//判断里面有没有 “Java”
if (i.next().equals("java")) {
//用迭代器添加d
i.add("android");
}
}
System.out.println(list);泛型&增强for泛型:是一种广泛的类型,把明确数据工作提前了编译时期,借鉴了数组的特点 泛型好处避免了类型转换的问题 可以减少黄色警告线 可以简化我们代码的书写 什么时候使用泛型查看API文档的时候,看到 < E > 的时候,就可以使用泛型
//创建集合
Collection<Student> c = new ArrayList<Student>();
//创建元素对象
Student s = new Student("张三", 18);
Student s2 = new Student("lisi", 19);
//添加元素对象
c.add(s);
c.add(s2);
//遍历集合对象
Iterator<Student> it = c.iterator();
while(it.hasNext()){
/*String string= (String)it.next();
System.out.println(string);*/
Student stu = it.next();
System.out.println(stu);
}
泛型的类型擦除泛型知识一种安全检测机制,只在编译时期有效 当源代码便以为Class字节码文件后,代码中是不存在泛型的,这称为泛型的类型查出 所以,集合本质能够储存Object类型是没有因为添加了泛型而发生改变的 泛型的定义位置类:class 类名< 泛型 > 接口:interface 接口名< 泛型 > 方法:public <泛型为C(也可以是别的)> void 类名(C c){} public < 泛型 C > C eat(C c){} //但会泛型对象 静态方法: public static < C > void eat {C c} 泛型的边界 < ? > :通配符泛型(表示不知道是什么泛型)没用,只能存储null < ? extends T >:上界通配符, 传入对象可以使用E类型及其子类对象 例题: List < ? extends Animal >,表示可以存入Animal及子类对象 < ? super T >:下界通配符 传入的对象可以使用E类型及其父类对象 例题: List< ? super Dog>,表示可以存入Dog及其父类对象 foreach的概述(增强for循环)作用遍历数组和集合 for(元素类型 变量名:数组或者集合对象){ //可以直接使用变量 //每次循环都会遍历出一个元素,保存到变量名中 } 例题int [ ] arr = {1,2,3}; for(int i : arr){ System.out.printLn(i); } 注意在增强for循环中不能修改集合,否则会出现并发修改异常 原因:增强for循环底层就是迭代器,所以不允许修改 常见数据结构数组特点 数组的长度一旦定义则不可改变 数组中的元素都有整数索引 数组只能存储同一类型的元素 数组既可以存储基本数据类型,也可以存储引用数据类型 查找快,增删慢 ArrayList 链表由链子链接起来的一堆结点 LinkedList 结点地址值,值,下一个节点地址值 特点查询慢,增删快 栈和队列栈先进后出(FILO ,First in Last Out)(子弹弹夹原理) 或者后进先出(LIFO , Last in First Out) 队列先进先出(FIFO , )(排队) List的特点和特有功能list接口(列表对象) 继承自Collection 接口,在java.util包下 特点有序的(存储和读取的顺序是一致的) 有整数索引 允许重复的 特有功能(都是List对象下的) 增 add(int index ,E element):在指定索引位置添加指定元素 查 get (int index):根据索引返回元素 删 remove (int index):删除指定元素并返回 改 set(int index , E element):将指定索引位置上的元素替换为指定元素 List的常用子类ArrayList :(底层是数组)查找快,增删慢 LinkedList :(底层是链表)查询慢,增删快 查询多,增删少,使用ArrayList , 如果查询少,增删多,使用LinkedList 不知道用啥的时候,用ArrayList LinkenListLinkedList常用功能: addFirst:添加到元素开头 addLast:添加到元素末尾 增 删 改 查 后面加First 是开头 后面加Last是末尾
HashSet集合HashSet< String > sss = new HashSet< String >( );创建对象 特点元素无序(存入和取出的顺序不一致) 元素不能重复 没有索引
遍历方法HashSet的add()方法,首先会使用点钱集合中的每一个元素和新添加的元素进行hash值比较 从Sutdent这个类newSutdent的时候,new了一个新的地址值,所以就算你存入的值(张三,18)一样,但是你new的地址值不一样,所以还是会都添加到HashSet对象中 所以要用 “地址值” 或者使用equals()方法比较 第一种:迭代器 Iterator 第二种:增强 foreach 第三种: 传入数组 (就变成了数组了) 在写一个class类的时候,里面写 get /set , 全参,无参 , toString , hashCode / equals 全写在里面!!!!!!!!!!! 如何判断重复HashCode( ) 这个比较的是地址值 equals( ) 这个比较的是值 如果直接添加HashSet对象里面,就不用了(没有别的泛型的时候比如(Student)) Collections工具类区别Collection 是集合体系的最顶层,包含了集合体系的共性 Collections 是一个工具类,是私有的,全是static修饰的,方法都是完全用于操作Collection的 方法binarySearch(List list ,Object key):使用二分查找指定元素在指定列表的索引位置(这个元素必须是排好顺序的) fill(List list,Object obj):使用指定的对象填充列表的所有元素 copy(List dest , List src): 将源列表中的数据复制到目标列表 (注意:目标列表的长度至少等于源列表的长度) reverse(List list): 反转集合中的元素 shuffle(List list): 傻否,随机置换(随机打乱集合中的元素的顺序) sort(List < T > list): 按照列表中元素的自然顺序进行排序(正序) swap(List list , int i , int j): 将指定列表中的两个索引进行位置互换
自然顺序:元素具有比较性 A - Z a - z 0 - 9 自定义的对象,需要自己手动用方法排序 斗地主案例练习模拟斗地主发牌的案例定义String[]数组, 存储4种花色定义String[]数组, 存储13个牌面值定义ArrayList, 作为牌盒为3个选手分别定义ArrayList, 作为手中的牌的集合牌盒加入以上牌和大小王, 调用Collections的shuffle方法洗牌发牌时, 留3张底牌, 每人发17张牌, 最后查看底牌和每个人的牌 package 上课02;
import java.util.ArrayList;
import java.util.Collections;
public class Test2 {
public static void main(String[] args) {
//花色
String [] color ={"黑桃","红桃","方片","梅花"};
//数字
String [] num = {"A","1","2","3","4","5","6","7","8",
"9","10","J","Q","K"};
//牌盒
ArrayList<String> 牌盒 = new ArrayList<>();
//遍历数组,存到集合
for(int x= 0 ; x < color.length ; x++){
for(int y = 0; y<num.length;y++){
牌盒.add(color[x] + num [y]) ;
}
}
牌盒.add("大王");
牌盒.add("小王");
//洗牌
Collections.shuffle(牌盒);
//赵三个牌友
ArrayList<String> 热巴 = new ArrayList<>();
ArrayList<String> 千玺 = new ArrayList<>();
ArrayList<String> 王俊凯 = new ArrayList<>();
//发牌
for (int i =0; i < 牌盒.size()-3; i++) {
/*
* i = 0 ;i % 3 = 0;
* i = 1 ;i % 3 = 1;
* i = 2 ;i % 3 = 3;
*
*/
if(i % 3 == 0){
热巴.add(牌盒.get(i));
}
else if (i % 3 == 1){
千玺.add(牌盒.get(i));
}
else if (i % 3 == 2){
王俊凯.add(牌盒.get(i));
}
}
System.out.println("热巴"+热巴);
System.out.println("千玺"+千玺);
System.out.println("王俊凯"+王俊凯);
//三张底牌
for(int x = 牌盒.size()-3;x<牌盒.size();x++){
System.out.println("底牌"+牌盒.get(x));
}
}
}
Map接口双列集合体系的顶层,以键值对方式储存,键不可重复,值可以重复 key-value(键值对)方式,一个键对应一个值 创建多态对象Map< String , String > map = new HshMap <>(); 储存在里面的值是什么类型的,别的或者自定义的也许 方法映射功能put(K key,V value):将key映射到value,如果key存在,则覆盖value,并将原来的value返回 获取功能get (Object key):根据指定的key返回key size():返回对应关系的个数 删除功能clear(): 清除 :清空所有的对应关系 remove(Object key): 删除 :根据指定的key删除对应关系,并返回key所对应的值,如果没有删除则返回null 判断功能isEmpty():判断集合是否为空(没有任何键值对)false就是不为空,true就是为空 containsKey(Object key):判断指定key是否存在(boolean) contionsValue(Object value):判断value是否存在(boolean) 遍历功能Set < Map.entry < K , V>> entrySet ( )
Set< K > keySet ( )
Collection< V > values ( )获取所有的方法获取key和valuesSet < K > keySet():取出key的键 例题:Set < 类型(String)> 变量名字 = map.keySet ( ) ; Collection< V > values ( ) :取出values的值 例题:Collection < 类型(String)> 变量名子 = map.values ( ) ; 获取所有值第一种
package 上课02;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test005 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("谢霆锋","张柏芝");
map.put("程冠希","陈欣彤");
map.put("李亚鹏","王菲");
Set<String> keySet = map.keySet();
for (String key : keySet) {
String string = map.get(key);
System.out.println(key +"--"+ string);
}
}
}第二种 entrySet():全部取出,然后封装起来
package 上课02;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/*
* Map的第二种遍历方式
* class 结婚证<K , V >{
* K 丈夫;
* V 媳妇
* }
*/
public class Test06 {
public static void main(String[] args) {
//创建Map对象
Map<String, String> map = new HashMap<>();
//添加映射关系
map.put("张三", "张三媳妇");
map.put("李四", "李四媳妇");
map.put("王五", "王五媳妇");
//获取所有的结婚证对象
Set<Entry<String, String>> entrys = map.entrySet();
//遍历包含了结婚证对象的集合
for (Entry<String, String> entry : entrys) {
//获取每个单独的结婚对象
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key +"---"+value);
}
}
}可变参数可变参数:当参数不确定的时候,类型要明确,Java可以把多个参数直接帮我们转成数组 格式类型 . . . 变量名 这是形参(可以在方法传形参的时候用) :类型 . . . 变量名 比如:int . . . sun 遍历还是像数组那样 实参 :一个参数一个参数的传 比如:sun(1,2,3,4.。。) 元素排序TreeSet类:元素可以排序 LinkedHashSet类:具有HashSet的元素不可重复的特点,而且还能不改变顺序 Set< Character > se = new LinkedHashSet<>();
异常异常包含了错误的类型,原因以及位置 ArithmeticException:冒号后面是异常的原因(数学异常) 异常体系结构Throwable :异常的超类(顶层) |_ Error:出现的不能够处理的严重问题 |_ Exception:可以处理的问题 # 编译时异常:编译时期就会发生的异常 |_ RuntimeExceptio # 运行时异常:编译时正常,运行时才会发生异常 常见异常NullPointerException ArrayIndexOutOfBoundExceptio at后面自己的包名,类名,方法名,行数 异常处理方式JVM默认处理方式如果出现异常我们没有处理,JVM会帮我们进行处理,把异常类型,原因和位置显示在命令行,并且还终止了程序,异常后面的代码将不在执行 try...catch处理方式 try{
可以有多行代码
有可能出现问题的代码;
}catch ( ArithmeticException ae (异常类型 异常对象名)) {
处理异常;
}
try{
}catch( ArithmeticException |Exception ae(里面可以写两个异常类型,用单或|) ){
处理异常;(系统繁忙,请稍后再试)
}try...catch的执行顺序: 首先执行try语句 如果发现异常,异常下面的代码不在执行,直接跳入catch语句,catch语句结束后,整个try...catch结束, 如果没有出现异常,try语句执行结束后,try...catch直接结束,不再执行catch语句 手动处理异常的2中方式 1:捕获异常并处理: 2:直接抛出异常: 异常的抛出处理方式处理不了的时候,我们就抛出异常,谁调用方法,谁处理异常 throws: 在方法名()throws 异常类型{ } Throwable顶层常用方法 getMessage():异常的原因 toString():异常的类型和原因 void printStackTrace():异常的类型,原因和位置
try{
可以有多行代码
有可能出现问题的代码;
}catch ( ArithmeticException ae (异常类型 异常对象名)) {
处理异常;
syso( ae.getMessage(); )
syso( ae.toString )
ae.printStackTrace()
}finally的概述和应用场景finally:组合try...catch使用,用于释放资源等收尾工作,它一定会执行 IO流处理异常 ↓
FileWrite fw = null;
try{
fw = new FileWrite("a.txt");
fw .write("hello");
这里写代码,比如输出流,
}catch( ArithmeticException |Exception ae(里面可以写两个异常类型,用单或|) ){
处理异常;(系统繁忙,请稍后再试)
}finally{
释放资源;
if(!fw = null){
try{
fw. close();
}catch(异常对象){
e.printStackTrace();
}
} 清理垃圾;
}异常的分类运行时期异常: RuntimeException的子类就是运行时期异常,在编译时期可以自由选择处理或者不处理 编译时期异常:Exception及其子类(除RuntimeException体系)在编译时期必须处理,一种抛出,一种捕获,用try...catch解决 自定义异常throws:用于抛出编译时异常,在方法声明上使用,由调用者处理 throw:制造异常的方式,并且结束方法 自定义一个异常类:写一个类去继承Exception或者RuntimEexception,然后实现多个构造即可 throw new Exception();或者 throw new RuntimEexception(); 递归阶乘:n! = n * ( n - 1 ) ! 递归:把大问题拆成小问题,小问题拆成更小的问题,一个个解决 在方法本身不断的调用方法自己 递归注意事项: 递归一定要有出口,内存溢出 递归次数不宜过多,内存溢出
public static int show(int n){
//出口(出口就是能够解决问题了,不用再在调用方法自己)
if(n == 1){
return 1;
}
return n * show(n-1);
}讲故事从前有座山,山里有座庙,庙里有个老和尚,老和尚在给小和尚讲故事, 从前有座山,山里有座庙,庙里有个老和尚,老和尚在给小和尚讲故事, 一直讲会累死,程序也一样,所有要有出口,而且不能次数太多!!!!!!!! 例题
public static void main(String[] args) {
int c = JC(5);
System.out.println(c);
}
public static int JC(int n) {
//出口
if(n == 1){
return 1;
}
return n * JC(n -1);
}斐波那契数列package 上课01;
public class 递归不死神兔 {
public static void main(String[] args) {
System.out.println(meth(20)); //6765
}
//定义方法,求第n个月的兔子数量
public static int meth(int n) {
//定义出口,第一个月和第二个月的兔子数量都是1
if(n==1){
return 1;
}
else if(n == 2){
return 1;
}else{
//如果是其他月,计算方式是 上个月兔子数+上上个月兔子数
return meth(n-1)+meth(n-2);
}
}
}
|