黑马程序员技术交流社区
标题: 【石家庄校区】Object，System，日期，包装类 [打印本页]
作者: 、呵呵呵 时间: 2018-4-14 19:42
标题: 【石家庄校区】Object，System，日期，包装类
本帖最后由 小石姐姐 于 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);
}
}
}
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |