黑马程序员技术交流社区

标题: 【石家庄校区】经验交流---JE07期_day05-day08笔记 [打印本页]
作者: 爪了个哇的    时间: 2018-4-14 18:18
标题: 【石家庄校区】经验交流---JE07期_day05-day08笔记
本帖最后由 小石姐姐 于 2018-4-20 09:54 编辑

经验交流---JE07期_day05-day08笔记

day05-day08学习笔记day05第一章  Object类和system类1.1 Object类
​        概述: Object类是java的根类,所有类的父类. 它中描述的所有方法,子类都可以使用
​        在Object类众多的方法中,我们先学习equals方法和toString方法,其他方法后面课程中会陆续学到
获取字节码对象的方式:
1.通过Object类的getClass()方法获取
2.通过类名调用属性class来获取
3.通过Class类的静态方法forName()来获取
快捷键生成toString方法            
public class EqualsDemo {        public static void main(String[] args) throws ClassNotFoundException {                Student s = new Student("小明",18);                //the way 1 通过Object类的getClass()方法获取                Class clazz1 = s.getClass();                //the way 2 .通过类名调用属性class来获取                Class clazz2 =Student.class;                // the way 3  通过Class类的静态方法forName()来获取                Class clazz3 = Class.forName("com.itheima_2.Student");                ​               
    System.out.println(clazz1.equals(clazz2)); //true
    System.out.println(clazz1.equals(clazz3)); //true
    System.out.println(clazz1.equals(clazz1)); //true
    System.out.println(clazz2.equals(clazz3)); //true
   
    同一个类的字节码都是一样的System类
System类
被final修饰  包含一些有用的类字段和 方法   它不能被实例化
复制数组:
​        static void arraycopy(Object src , int srcPos , Object dest, int desPos , int length )
src : 源数组
srcPos:从源数组的哪个索引开始复制
dest :  目标数组
desPos : 从目标数组的第几个索引开始接收
length:   目标数组接收源数组的索引个数    不能超过目标数组的长度
调方法 用sysytem类名 点  方法名
​
int[] src ={1,2,3,4,5,6,7,8,9};
int[] desk = new int [6] ;
System.arraycopy(src,0,desk,0,4);//1,2,3,4,0,0
System.arraycopy(src,0,desk,0,6);//1,2,3,4,5,6
System.arraycopy(src,0,desk,0,7);java.lang.ArrayIndexOutOfBo                undsException  索引越界
System.out.println(Arrays.toString(desk));返回当前的系统时间:
​        static  long currentTimeMillis()
​                以毫秒值返回当前的系统时间 从  1970-1-1 0:0:0至今的毫秒数

    1000毫秒=1秒;
    相对于1970-1-1 0:0:0   0
   
    现在的时间
    long now = System.currentTimeMillis();  时间都是毫秒 终止虚拟机的运行:
​        static void exit(int status)
Data类 :
表示特定的瞬间,精确到毫秒,它可以通过方法来设定自己表示的时间,可以                                表示任何的时间
​        //system.currentTimeMillis();  返回的是当前的系统时间,1970-1-1 至今的毫秒数
构造方法[td]
构造方法摘要
**Date**()           分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
**Date**(long date)           分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
无参         Date(): 创建时一个表示当前系统时间的Data对象
有参         Date(long data)  :根据 指定的时间创建Data对象
需要导包  :   import java.util.Data;
Date a = new Date();
System.out.println(a.getTime());//1523179137820
Date a1 = new Date(0);
System.out.println(a1.getTime());//0
System.out.println(a.toLocaleString());//2018-4-8 17:18:43
​
toLocaleString  :  当地时间的字符串
Date的常用方法:
​        毫秒值 - - - Date对象
​                设置
​                返回值时void  参数是long
​                        void  setTime(long Time)

void  setTime(long Time)  设置时间  
​        Date - - -毫秒值
​                获取
​                返回long,无参数

long.getTime()          获取时间
SimpleDataFormat
SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。
格式化
                 Data - - -String
​                2049-8-26   2049年8月26日
​        

    String format(Data data)
解析:
​                String - - - Data
​                "2049 -8 -26 "
​        

    Data parse(String source)构造方法:
​                SimleDataFormat()        使用默认的模式进行对象的构建

SimpleDateFormat sdf = new SimpleDateFormat();
Date date = new Date();
String s = sdf.format(date);
​
//jiexi
Date d = sdf.parse();
​                SimleDataFormat(String pattern) 使用指定的模式进行构建
[td]
字母
日期或时间元素
表示
示例
GEra 标志符
AD
y年
1996; 96
M年中的月份
July; Jul; 07
w年中的周数
27
W月份中的周数
2
D年中的天数
189
d月份中的天数
10
F月份中的星期
2
E星期中的天数
Tuesday; Tue
aAm/pm 标记
PM
H一天中的小时数（0-23）
0
k一天中的小时数（1-24）
24
Kam/pm 中的小时数（0-11）
0
ham/pm 中的小时数（1-12）
12
m小时中的分钟数
30
s分钟中的秒数
55
S毫秒数
978
z时区
Pacific Standard Time; PST; GMT-08:00
Z时区
-0800
解析的对象必须和默认的模式一样  
使用指定的模式:

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
//格式化
Date date = new Date();
String s = sdf.format(date);
​
Calendar  日历

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。
abstract修饰  抽象类  
Calendar类静态方法
Calendar c = Calendar.getInstance(); //返回当前时间
方法 :  
​        修改 :
​        添加:
​        获取:

**package** com.itheima_05;
**import** java.util.Calendar;
/*
* Calendar：日历，提供了一些操作年月日时的方法
*
* 获取
* 修改
* 添加
*
*
*/
**public** **class** CalendarDemo {
    **public** **static****void** main(String[] args) {
        //static Calendar getInstance()  
        Calendarc = Calendar.*getInstance*();
  
        //void set(int field, int value) ：把指定的字段修改成指定的值
        //c.set(Calendar.DAY_OF_MONTH, 20);
        
        //void add(int field, int amount): 在指定的字段上加上指定的值
​
        c.add(Calendar.*DAY_OF_MONTH*, -1);
        
        //int get(int field) // 返回给定日历字段的值
        //public static final int YEAR 1
        //System.out.println(Calendar.YEAR);     
        //int year = c.get(1);
        **int** year = c.get(Calendar.*YEAR*);
        **int** month = c.get(Calendar.*MONTH*) + 1;
        **int** day = c.get(Calendar.*DAY_OF_MONTH*);
        System.*out*.println(year + "年" + month + "月" + day + "日");
    }
}
包装类:
byte      Byte
short         Short
char         Character
int                Integer
long        Long
构造方法
​        Integer(int value)
​        Integer(String s )

Test    //Integer(int  value)
        Integer i = new Integer(10);
        System.out.println(i);
        // Integer(String s)
        Integer i1 = new Integer("11");
        System.out.println(i1);
        
        // int intValue()
        int i3 = Integer.valueOf(12);
        System.out.println(i3);
        // static int parseInt(String s)
        String s = Integer.toString(13);
        System.out.println(s);
        
        //static String toString(int i)
        int i4 = Integer.parseInt("14");
        System.out.println(i4);
​
​
自动装箱和拆箱
​        //自动装箱   基本数据类型转换为包装类
​        Integer i= 10;  //自动装箱  相当于Integer i = new Integer(10);
​        int a = i ;  //自动拆箱    int  a = i . intValue();   包装类可以自动转换成基本数据类型
​         
​        ArrayList  list = new intValue();
​        list.add(10);  //自动装箱
正则表达式:
是一种用于匹配字符串的规则;
可用于判断字符串是否符合某种规则,比如是否是邮箱,是否是手机号等等.
Pattern类:
​        创建正则表达式模板,内有正则表达式的规则
常用规则 : 具体查看API模板
​        字符:
​               

x :
\\ :
[abc]:DAY_06                        集合
Collection
List
ArrayList
Collection接口 (单列集合体现)  顶层接口常用方法:
boolean add(E e):  添加元素  添加成功返回ture   否则false
void clear()
boolean isEmpty()
boolean remove(Object o )
int size()
Object toArray()  将集合转换成一个Object类型的数组
迭代器Iterator  接口
作用
提供遍历集合的安全方式:获取迭代器

迭代器  运行先指向第一个元素前面的位置  需要先判断有没有下一个       元素.hasNext() 是否有下一个元素
      
使用集合对象调用Interator<E>  iterator()方法
成员方法:
hasNext()         方法:判断集合中是否有元素可以迭代
next()                 用于返回迭代的下一个元素
void remove()     从迭代器指向的

集合的遍历方式:
    1.toArray(),可以把集合转化成数组,然后遍历数组即可
    2.iterator(),可以返回一个迭代器对象,我们可以通过迭代器对象迭代集合
   
Iteartor :  用于遍历集合
E next : 返回下一个元素
    arr.next();使用next方法获取元素,可能会抛出NOSUCH异常
    所以我们呢要使用hasNext()方法 判断是否有下个元素
​
Iterator  是依赖于集合的,相当于集合的一个副本,当迭代器在操作是 ,发现和集合不一样的时候就会抛出异常

Exception in thread "main" java.util.ConcurrentModificationException:并发修改异常
​        解决方案:在使用迭代器遍历的时候,使用迭代器去修改        Iterator 里没有这个方法
ListIterator  Iterator的子类接口  
泛型  
由于集合可以i存储任意类型的对象,当我们存储了不同类型的对象,就可能在转换的时候出现类型转换异常,所以java为了解决这个问题,给我们提供了一种机制,叫做泛型.
泛型  是一种广泛的类型,把明确数据类型工作提前到编译时期
好处:
​        避免了类型的转换问题
​        可以减少黄色警戒线
​        可以简化我们代码的书写
什么时候使用泛型?
​        当我们看到<E>  就可以使用泛型
foreach增强for循环
作用  遍历数组和集合
格式:  for(元素类型  新变量名:数组或集合对象){
可以直接使用变量   //每次循环都会遍历出一个元素,保存到变量名中
​        }
​        for( ){
​        //
​        }
常见的数据结构
ArrayList类(底层是数组,查询快,增删慢)
LinkedList类 (底层是链表,查询慢,增删快)
​        void addFirst(E e)添加元素到集合
​        void addEnd(E e) 添加元素到结尾

​
数组 int[] arr = {1,2,3,4,5};
​
数组的特点:
​
    长度一旦定义不会改变
​
    数组中的元素都有整数索引
​
    数组只能存储同意类型的于那苏
​
    数组既可以存储基本数据类型,也可以存储引用数据类型
​
如何获取数组的元素   arr[2]
如何在元素3的后面加一个新的元素8,howtodo
    首先创建一个新的数组  长度+1  
    遍历源数组 当碰到3的时候 在元素3的后面添加新的元素8
    最后把剩下的元素添加到8后面
数组在操作上的特点:
    查找快,增删慢
   
链表:有链子链接起来的一堆节点;
节点:地址值,值,下一个节点的地址值
​栈和队列栈  : 先进的后出   后进的先出来
​        弹夹 :
​               
队列 : 先进先出
​        排队买票:
List类
​        有序的collention  
特点:
​        有序的(存储和读取的顺序是一致的)
​        有整数索引
​        允许重复的

List的特有功能
    void add(int index, E element);
    E get(int index)
    E remove(int index)
    E set(int index , E element)
   
    //void add(int index, E element); 在指定索引添加元素
    list.add(0,"hello");
    list.add(0,"world");
    打印结果 是    world  hello
    list.add(0,"hello");
    list.add(0,"world");
    list.add(1,"java");
    打印结果 是    world java hello
   
   
    //E get(int index)  根据索引返回元素  会有越界
    for(){
        list.get(i)
    }
   
    E remove(int index)  删除指定索引的元素
   
        list.remove(2)
   
    E set(int index , E element)//将指定位置的元素修改围殴EList的子类,LinkedList特有功能
List的子类
​        ArrayList  底层的数组结构,查询快,删除慢
​        LinkedList 底层的链表的结构,查询慢,增删快
​                特有的方法: 用于处理开头和结尾的元素
LinkedList的一些方法
void addFirst(E e):将元添加到开头
void addLast(E e):          结尾
E getFirst()  获取开头的元素
E getLast()   获取结尾size()-1的元素
E removeFirst() 删除第一个
E removelast()  删除最后一个
​
file://C:/Users/ADMINI~1/AppData/Local/Temp/1523358976838.png?lastModify=1523700651
day07集合(HashSet,HashMap,Map集合嵌套)Set体系的特点
HashSet存储字符串并遍历
创建集合对象
    //HashSet<String>   hs = new HashSet<String>();
    Set<String> hs = new HashSet<String>();父接口指向子类对象
添加元素对象
hs.add();
遍历   //  没有索引   三种方式:  转数组    迭代器    ForNB
​
​
Set接口 继承自Collection 接口
Set集合的特点:
HashSet集合
Student s = new student("张三",18);
Student s = new student("张三",18);
Student s = new student("李四",18);
​
三个学生对象都可以i存入HashSet 里  ,这是因为:
    通过查看源码发现:
        add()方法,首先会使用当前集合的每一个元素和新添加的元素进行Hash值比较
        如果hash值不一样,则认为不重复,会直接添加
        如果hash值一样,则继续和已有元素比较地址值  或者使用equals方法
        如果和所有的已有元素比较都不一样,则认为
        
我们发现当hashcode方法永远返回1,所有对象的hashcode方法        的比较
如果我们可以让
Collections工具类
​        collection和collections的区别:
​        Collection是集合体系的最顶层,包含了集合体系的共性
​        Collections是一个工具类(方法static修饰,使用类名就可以调用),方法用于操作Collection
​        

static int binarysearch(List list,Object key) 使用二分查找指定元素在列表中的位置,折半查找(集合必须是拍好顺序的)
static void copy(List dest,List src)//覆盖
​
static void fill(List list, Object obj)//使用指定的对象,填充到列表中的所有元素
list.add("hello");
list.add("hello1");
list.add("hello2");
​
Colletions.fill(list , hehe);
syso    hehe  hehe  hehe
​
static void reverse(List list)//反转
​
static void shuffle( )  //随机置换  顺序
static void sort( )  //按照列表中元素的自然顺序进行排序
static void swap(List list , int i , int j)//将列表中的两个索引位置进行互换  
    HashMap集合
Map接口概述:
​        我们通过查看map接口描述,发现Map接口下的集合和Collection接口下的集合,他们存储数据的形式不同
​        1.Collection 中的集合,元素是孤立存在的,单身  ,向集合中存储元素采用一个个元素的方式
​        2.Map中的集合  元素是承兑存在的(理解为 夫妻 )  每个元素由键与值两个部分组成 通过键找到对应的值

3. collection中的结婚成为单列集合,Map中的集合成为双列集合
Map中不能包括重复的键,但值可以重复.每个键只能对应一个值Map中不能包括重复的键,但值可以重复.每个键只能对应一个值Map中不能包括重复的键,但值可以重复.每个键只能对应一个值
Map的常用功能
​        

1.映射功能
V put(K key , V value):以键=值的方式存入Map集合   
        将K映射到Value的功能   有福哦有Key存在,则覆盖Value,并将原来的Value返回
2.获取功能
V get(Object key): 根据键获取值   
int size()   返回Map键值对的个数
​
3.判断功能
boolean containskey(Object key);
        判断Map集合中是否包含键位key的键值对
        判断Key是否存在
boolean containsValue(Object value)
        判断Map集合中是否包含值为value键值对
        判断指定的Value是否存在//map.containsValue("王五")
boolean isEmpty()  判断Map集合中是否没有任何键值对
​
4.删除功能
​
void clear()  
        清空Map结合中所有的键值对
V remove(object key)  
        根据键值删除Map中的键值对  
        根据指定的Key删除对应关系.并返回Key所对应的值,如果没有删除返回null
​
5.遍历功能
Set<Map.Entry<K,V>>   entrySet()  
    将每一个键值对封存到一个个Entry对象中,再把所有的Entry的对象封存到Set结婚中返回.,
   
​
​
​Set<k>   KeySet();  //以set的形式返回所有的Key
​                Set<String> keys = map.KeySet();                Collection<String> values()  // 获取所有的值
collection<String> keys = map.KeySet();
​                for(String keys : key)

public class KeySet_ValueDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String , String >();
        
        //添加内容
        map.put("ITCAST001", "张三");
        map.put("ITCAST002", "李四");
        map.put("ITCAST005", "李四");
        
        //利用keySet获取所有的key,并且遍历出所有的key
        //Set<k>   KeySet();  //以set的形式返回所有的Key
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key);
        }
        
        //利用values方法获取所有的value,并且遍历所有的value
        //Collection<String> values()  // 获取所有的值
        Collection<String> values = map.values();
        for (String value : values) {
            System.out.println(value);
        }
        
    }Map的遍历第一种方式:  获取所有的key---遍历每一个key---用key去找他对应的value
​               

//创建map对象
​
//添加映射关系
​
//遍历map对象
​
//获取所有的key
​
//遍历所有的key
    //通过key来获取value
   
   
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        //映射对象
        map.put("谢婷疯 ", "张箔纸");
        map.put("陈关西", "钟欣桶");
        map.put("李亚碰", "王飞");
        
        //第一种方式  使用KeySet
        Set<String> keys = map.keySet();
        for (String key : keys) {
            //通过Key获取value
            String s = map.get(key);
            //打印键值对
            System.out.println(key+"\t"+s);
        }
    }Map遍历的第二种方式
Set<Map.Entry<K,V>>   entrySet()  
    将每一个键值对封存到一个个Entry对象中,再把所有的Entry的对象封存到Set结婚中返回.,
//创建Map对象
//添加映射关系
//获取所有的Entry证对象
//遍历包含了Entry对象的集合
//获取每一个单独的Entry对象
//通过Entry对象获取丈夫和妻子
​
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
​
map.put("尹志平","小龙女");
map.put("令狐冲","东方菇凉");
map.put("玄慈","叶二娘");
​
Set<Map.Entry<String, String>> entry=map.entrySet();
​
for (Entry<String, String> entry2 : entry) {
String key = entry2.getKey();
String value = entry2.getValue();
System.out.println("丈夫:"+key+"\t\t"+ "妻子"+value);
​
}
}Map中key是类的Test创建一个学生类,重写toString方法方便遍历//创建Map对象//创建Key对象//添加映射关系//遍历map对象

可变参数:
方法的形参可以一传入不定数量个参数
适用于  参数不确定的时候,类型要明确,Java可以把多个参数直接帮我们转化成数组
实参: 一个参数一个参数的传递
形参:类型 ... (三个.) 变量名
JDk1.5之后
注意:在可变参数之后不可以追加参数, 在可变参数前面可以追加
​        参数的数量自定义 可以给多个  也可以一个都不给
增强for循环
1.把数组中的元素添加到集合
int[] arr = {1,2,3,4,5,6};
for(int  i  :  arr){
​        hs.add(i);
}
2.要把集合转成数组  不能直接转int[]  可以转Integer[]
//int[] arr = new int[hs.size()];
Integer[] arr = new Integer[hs.size()];
hs.toArray(arr);
\
3.Character  而不是char
利用HashCode
让对象实现排序的两种方式:
​        让对象具有自然顺序:让JavaBean实现Comparbale接口,重写co'mpareTo() 方法
​        使用比较器:定义一个类作为比较器,实现Comparator接口,重写compare()方法,排序时传入该比较器实现类的对象
重写方法的返回值的作用:
​        返回值为负数,
方式一: 让元素实现Comparable接口  
class Dog implements Comarable<Dog>{
    int age;
    public Dog(int age){
        super();
        this.age = age;
    }
    @Override
    public int compareTo(Dog o){
   
        return this.age- age;
    }
}
​
​
方式二:
class  CatComparator implements Comparator<Cat>{
    @
    public int compare(Cat cat1 , Cat cat2){
        
        return cat1.age - cat2.age;
    }
}day08
异常包含了错误的类型,原因以及位置
异常:不正常,我们在代码的时候出现编译或者运行时候出的错误;
异常的体系结构:
Thowable 是异常的超类
​        Error:         出现的不能处理的问题.
​        Exception  :  出现了可以处理的一些问题    编译时异常
​                        RuntimeException  运行时异常:编译正常 运行出错
常见异常:
​        NullPointerException
​        ArrayIndenxOutOfBoundException
任何数字除以0 都会抛出异常
异常的处理方式JVM默认处理方式:如何处理多个一异常
可以使用多个try..catch语句
​        使用一个try   和  多个 catch
多个catch之间的顺序  
​        多个catch之间可以有子父类关系
​        平级之间没有顺序关系
​        如果有子父类,父类异常必须放在子类的后面
1.NullPointException  空指针异常2.ArrayIndexOutOfBoundsException  数组越界

异常的顶层 Throwable
常用的三个方法:
String  getMessage()    返回出现异常的原因   没有异常原因返回的话返回null
String  toString();                返回错误类型和原因
void printStackTrace();返回类型原因和位置,与虚拟机的区别: 这种处理,之后的代码会执行,而虚拟机处理后,后面的代码不会执行.
小拓展System.err.print("okok");  打印出来的字体时红的

finally的概述和应用场景try{    有可能出现问题的代码}catch(){        处理异常}finally{        释放资源        处理垃圾}

异常的分类:
编译异常
编译时期异常:Exception的子类,非RuntimeException的子类,在编译时期必须处理(try..catch或者throws)

运行异常
空指针异常;syso(2/0);数组越界 ; 等运行时期异常:RuntimeException的子类就是运行时期异常,在编译时期可以自由选择处理或者不处理

自定义异常:
​        自定义编译异常



递归
一种把问题由大化小,从小到大依次解决的思想;
在方法本身不断的调用方法自己
递归注意事项:
​        递归一定要有出口,内存溢出
​        递归次数不宜过多,内存溢出









欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2