黑马程序员技术交流社区

标题: 【石家庄校区】学习笔记 [打印本页]

---

作者: ayangjianling    时间: 2018-4-14 17:47
标题: 【石家庄校区】学习笔记


                                                           学习笔记
object

objectd  tostring方法
    string tostring():返回该对象的字符串表示
        boolean equals(object obj )
        getclass():返回一个字节码对象
        Integer.toHexString():返回指定参数的十六进制字符串形式
        hashCode():返回该对象的哈希码值(内部地址)
获取自字节码的3种方式
                1.通过object类的getclass()方法获取  ------ 对象.getClass()方法
                Teacher teacher =new Teacher();有对象使用这一方式
                Class clazz=teacher.getClass();
                2.通过类名调用属性class来获取 ------ 类名.class属性
                Class clazz2= Teacher.class;
                3. 通过class类的静态方法forName()来获取  ------- class.forName("类的全名")
                Class class1=Class.forName("com.itheima07.Teacher");推荐使用这一方式
object的equals方法
前提:需要重写否则比较的是地址值
     boolean equals(object obj )
           使用==来比较俩个对象是否相等,则比较地址值是否相等
           
                                      system
                                                                  
system:包含一些有用的类字段和方法,它不能被实例化
           static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
           复制数组
                    src:源数组
                   srcPos:指定从哪个索引位置开始复制
                   dest:目标数组
                   destPos:指定目标数组接收元素的索引位置
                   length:目标数组接收元素的个数
                   例子:int[]src={1,2,3,4,5};
                    int []dest=new int[5];
                   //System.arraycopy(src, srcpos, dest, destpos, length);
                     System.arraycopy(src, 0, dest, 0, 5);
                     for(int i=0;i<dest.length;i++){
                               System.out.print(dest);
                       }
                  ---------------------------------------------------------------
                  
           static long currentTimeMillis()        
           返回当前系统时间
                   1000毫秒=1秒
                   0:0:1 =1000毫秒
                   0:1:0=1000*60
                   1:1:0=1000*60*60+1000*60
                  
           static void exit(int status)    非 0 的状态码表示异常终止。 0表示正常终止
                   终止虚拟机的运行
                                               Data
  Date:                表示特定的时间,精确到毫秒它可以通过方法来设定自己所表示的时间,可以表示任意的时间
            构造方法:
              Date():创建的是一个表示当前系统时间的Data对象
                          Date(long date):根据"指定时间" 创建Data对象
                  例子:Date data=new Date(1000*60);
                       ystem.out.println(data.toLocaleString());
                         常用方法: 毫秒值----Date
                                                设置 setTime
                                                返回值是void,参数long
                                                void setTime(long time) 设置Date对象的时间
                                                Date-----毫秒值
                                                  获取getTime
                                                  返回值是long,无参数
                                                  long getTime()获取Date对象中保存的时间毫秒值
                                                  
                                                  
                                                  
                          simpleDateFormat类(格式化):      专门用于格式化和解析时间
                                        格式化: Date对象-->指定格式的字符串,如2017-05-01 12:34:12
                                          
                                          String  format(Date date):格式化Date对象返回字符串

                                        解析: 字符串->Date对象
                                          
                                                Date parse(String source):将字符串解析为Date对象
                                构造方法:
                                    simpleDateFormat();使用默认的模式进行对象构建
                        格式:        simpleDateFormat        simpleDateFormat(String pattern):使用指定的模式进行对象的构建
                   例子:package com.itheima07;

                                import java.text.ParseException;
                                import java.text.SimpleDateFormat;
                                import java.util.Date;

                                /*
                                 * 按要求实现以下需求
                                将当前日期格式化为”xxxx年xx月xx日”并打印
                                已知日期字符串”2000-10-01”
                                将该日期字符串格式化为日期对象,获取该日期对象的毫秒值并打印
                                 */
                                public class test07 {
                                public static void main(String[] args) throws ParseException {
                                        Date data=new Date();
                                        SimpleDateFormat simpleDateFormat=new  SimpleDateFormat("yyyy年MM月dd日");
                                        String string=simpleDateFormat.format(data);
                                        System.out.println(string);
                                        System.out.println("---------");
                                        String date2="2010-10-24";
                                        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

                                           Date date  =sdf.parse(date2);
                                           System.out.println(data);
                                           long mils=date.getTime();
                                           System.out.println(mils);
                                }
                                }   

                          
                                 
                                 
                                  练习求出你来这个世界上多少天的案例                 
               
                     


                           import java.text.ParseException;
                                import java.text.SimpleDateFormat;
                                import java.util.Date;

                                public class test08 {
                                public static void main(String[] args) throws ParseException {
                                        //出生日期
                                                String  birthday="1996-06-11";
                                                //今天日期
                                                String now ="2018-04-09";
                                                SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
                                                //将字符串转换为日期
                                                Date  date=simpleDateFormat.parse(birthday);
                                                Date date2 =simpleDateFormat.parse(now);
                                        //将日期转换为long的毫秒值
                                        long birthdaymils=date.getTime();
                                        long nowmils=date2.getTime();
                                       
                                        System.out.println((nowmils-birthdaymils)/1000/60/60/24);
                                       
                                        }
                                }
                                
                                Calendar:日历 提供了一些操作年月日时的方法
                                创建对象
              静态方法:  static Calendar getInstance()
                         示例:  Calendar c = Calendar.getInstance();
                                获取  int get(int field) 获取指定的日期字段
                                修改 void add(int field,int amount):增加或减少指定的日期字段值(调整时间)
                                calendar.add(calendar.DAY_OF_MONTH,-1);
                                添加 void set(int field,int value):设置指定的日期字段值(设置时间)
                                calendar.set(calendar.YEAR, 2000);
                                Calender 抽象类。日历，提供操作日期字段的方法
                        static
                                Calendar getInstance()        //获取对象，默认当前时间
                                int YEAR                        年
                                int MONTH                        年中月（0-11）
                                int DAY_OF_MONTH        月中天
                                int HOUR                        小时(12小时制)
                                int HOUR_OF_DAY         小时(24小时制)
                                int MINITE                        分钟
                                int SECOND                        秒
                                int DAY_OF_WEEK         周中天（1-7，周日-周六）
                                int DAY_OF_WEEK_IN_MONTH         月中周
                                int DAY_OF_YEAR         年中天

                                
                                
                                
                                
                        包装类:  character Integer(关键词)
                                就是封装了基本数据类型的类,为我们提供了更多复杂的方法和一些变量
                                
                                Integer
                        
                        构造方法
                        
                                        Integer(int value) : int转Integer
                                        Integer(String value) : String转Integer
                        成员方法
                                        int intValue() : Integer转int
                                        String toString() : Integer转String
                                        static int parseInt(String value) : String转Integer
                        整数基本类型和包装类转换
                                        int转Integer
                                        利用Integer的构造方法:  Integer Integer(int value)
                                        如:  Integer i = new Integer(10);
                                        Integer转int
                                        利用Integer的成员方法:  int intValue()
                                        如:  int a = i.intValue();
                        字符串和整数转换
                                        String转int/Integer
                                        方式1:  Integer Integer(String s)
                                        如:  Integer i = new Integer("10");
                                        方式2:  static int parseInt(String s)
                                        如:  int a = Integer.parseInt("10");
                                        方式3:  static Integer valueOf(String s)
                                        如:  int b = Integer.valueOf("10");
                                        int/Integer转String
                                        方式1:  "" + int值
                                        如:  String a = "" + 10;
                                        方式2:  String toString()
                                        如:  String a = i.toString();
                                        方式3:  static String toString(int i)
                                        如:  String a = Integer.toString(10);
                                                                                
                        正则表达式:就是一套规则可以用于匹配字符串
                格式:        String类
                 boolean matches(String regex) : 当前字符串是否匹配指定的正则表达式
                        Pattern 类:
                                创建正则表达式模板, 内有正则表达式规则
                                常用规则: 具体查看API文档的Pattern类
                                字符:
                                        x : 一个字符x a b c "abc" "aab"
                                        \\ : 表示 \ 反斜杠.
                                        为什么有2个? 第一个 \ 是转义的作用
                                        [abc] : a或b或c, 即中括号字母中的其中一个 [abc]{2} "aa"
                                        [^abc] : 除a, b, c之外的任何字符.
                                        ^ 表示否定
                                        [a-zA-Z] : 小写英文a到z, 以及大写英文A到Z.
                                        - 表示范围
                                        预定义字符
                                        . : 任何字符(对于行结束符, 可能匹配, 也可能不匹配)
                                        \d : 数字0-9. 相当于 [0-9]
                                        d是digital的缩写
                                        \D : 非数字. 相当于 [^0-9]
                                        \s : 空白字符. 相当于 [ \t\n\x0b\f\r] , 包括空格(第一个空就是空格)
                                        s是space的缩写
                                        \S : 非空白字符. 相当于 [^\s]
                                        \w : 单词字符. 相当于 [a-zA-Z_0-9]
                                        w是word的缩写
                                        \W : 非单词字符. 相当于 [^\w]
                                        Greedy数量词
                                        X? : X这个字符出现一次或零次
                                        X* : X这个字符出现零次或多次, 包括一次
                                        X+ : X这个字符出现一次或多次
                                        X{n} : X这个字符恰好出现n次
                                        X{n, } : X这个字符至少出现n次
                                        X{n, m} : X这个字符至少出现n次, 但不超过m次
                                       
                                切割字符串:        
                                        String类
                         String[] split(String regex) : 按照正则表达式切分当前字符串为多个部分, 返回每个部分组成的字符串数组, 其中不包含分隔符
                         集合
                Arraylist     string tostring():返回该对象的字符串表示     数组用length  集合用size
                 集合的体系结构:
                      由于不同的数据结构(数据的组织,存储方式),所以java为我们提供不同的集合
                          将不同的集合实现类的共性向上抽取取出父类,从而形成一种体系
                        collection是接口不能实例化



                        
                Collection中的常用功能
                如何创建Collection对象?
                                本身是接口, 实际使用的是子类对象. 使用多态,  Collection c = new ArrayList<>();
                                常用方法
                                增
                                boolean add(E e) : 向集合中添加元素, 添加成功返回true, 添加失败返回false. 永远能够添加
                                成功
                                删
                                boolean remove(Object o) : 删除元素中的指定元素, 删除成功返回true, 删除失败返回false
                                void clear() : 清空集合中的元素
                                判断
                                boolean contains(Object o) : 判断集合中是否包含指定元素, 包含返回true, 否则false
                                boolean isEmpty() : 判断集合是否为空集合, 即没有元素. 没有元素返回true, 否则false
                                获取个数
                                int size() : 获取集合中元素的个数
                                转换
                                Object[] toArray() : 将集合转换为Object[]
                                T [] toArray(T[]a):传入T类型数组,将集合中元素存储到数组中
                                
                                
                  获取迭代器
                  
                  格式:Iterator<Integer> lIterator=list.iterator() ;
                                Iterator 接口:
                                                迭代器
                                                作用:
                                                提供遍历集合的安全方式
                                                获取迭代器:
                                                使用集合对象调用 Interator<E> iterator() 方法
                                                成员方法
                                                boolean hasNext() : 是否有下一个元素
                                                E next() : 返回下一个元素
                                                void remove() : 从迭代器指向的 collection 中移除迭代器返回的最后一个元素
               
               
               
               
                并发修改异常解决方案:
                并发修改异常:
                                                ConcurrentModificationException
                                                并发:
                                                并行发生, 即同时发生
                                                修改:
                                                指的是会改变集合长度的操作
                                                增加元素
                                                删除元素
                                                清空元素
                                                list的 set(int index, Object o) 方法可以修改集合中某个索引处的元素值, 但并不会改变集
                                                合的长度, 所以不会发生并发修改异常
                                                发生原因:
                                                迭代器依赖于集合, 相当于集合的一个副本, 当迭代器在操作时, 如果发现迭代器的副本和集合不一
                                                样, 则抛出并发修改异常
                                                如何避免:
                                                // 添加元素
                                                collection.add("Hello");
                                                collection.add("world");
                                                collection.add("java");
                                                // 方式1: 转换为Object[]
                                                Object[] arr = collection.toArray();
                                                for (int i = 0; i < arr.length; i++) {
                                                System.out.println(arr);
                                                }
                                                System.out.println("-------------");
                                                // 方式2: 使用迭代器
                                                // 先通过集合对象获取迭代器对象
                                                Iterator iterator = collection.iterator();
                                                // 循环迭代
                                                while (iterator.hasNext()) {
                                                System.out.println(iterator.next());
                                                }
                                                }
                                                }
                                                方式1: 不使用迭代器
                                                方式2: 在使用迭代器遍历时, 使用迭代器的方法修改
                                                添加元素:
                                                List接口中的 ListIterator listIterator() 获取用于List的迭代器, 然后调用
                                                ListIterator的add()方法
                                                删除元素: remove()
                                                List接口
                                                列表, 是Collection的子接口
                                                特点:
                                                元素存取有序, 元素可以重复, 有索引

                                                
                                                
                                                
                                                
                  泛型:  
                                                Generic type, 广泛的通用的类型, 具体什么类型由开发者定义
                                                为什么出现泛型?
                                                由于集合可以存储任意类型的对象, 所以可以按照Object类型存入, 如果我们向集合中存储不同类型
                                                的对象后再遍历出来元素, 都是Object类型, 若要使用该类型的方法, 必须进行类型转换, 有可能发生
                                                类型转换错误
                                                例如:
                                                集合中存储了Student对象和String对象, 迭代出元素后并不知道具体是什么, 强转或调用方法
                                                时可能出错
                                                好处:
                                                避免类型转换问题
                                                减少警告
                                                简化代码书写
                                                作用:
                                                用于明确数据类型
                                                将运行时才发生的类型转换问题, 提前到了编译时期
                                                如何使用:
                                                出现 <某个字母> 的地方, 就可以使用具体的数据类型替代这个字母
               
               
               
               
                增强for: foreach 遍历数组和集合
                    for (int i = 0; i<arr.length;i++) {
                                        int a = arr;
                                        }
                                        for (元素类型 变量名: 数组或集合对象) {
                                        // 每次循环都会遍历出一个元素, 保存到变量名中
                                        }
                                        int[] arr = {1,2,3};
                                        for (int i : arr) {
                                                system.out.println(i);
                                                                           }
               
               
               
                List:
                格式:list list=new ArrayList();
                 List 接口
                                继承自 Collection 接口. 在 java.util 包下
                                特点
                                元素有序(存入和取出的顺序一样)
                                有整数的索引
                                元素可以重复
                                特有功能 (都是按索引进行操作的)
                                void add(int index, E element) : 添加元素
                                E remove(int index) : 删除元素
                                E set(int index, E element) : 修改元素
                                E get(int index) : 获取元素
                        list的常用子类:
                           Arraylist
                                底层是数组结构,查询快,增删慢
                                Linkedlist
                                  格式:
                                     Linkedlist  list=new Linkedlist();
                                    底层是链表,查询慢,增删快
                                如何使用不同的集合?
                                   如果查询多,增删少,就用Arraylist
                                   如果查询少,增删多,就用Linkedlist
                                   如果你不知道用什么,就使用Arraylist
                        LinkedList的特有功能
                           LinkedList底层使用的是链表结构,因此增删快,查询相对ArrayList较慢
                                void addFirst(E e) :向链表的头部添加元素
                                 void addLast(E e):向链表的尾部添加元素
                                 E getFirst():获取链头的元素,不删除元素
                                 E getLast():获取链尾的元素,不删除元素
                                 E removeFirst():返回链头的元素并删除链头的元素
                                 E removeLast():返回链尾的元素并删除链尾的元素
               
               
               
               
               
                set接口
                  格式: set<string> set =new hashset<string>();
                  遍历集合对象
                                1. 转数组
                                                string[]arr=list.toArray();
                                                2.迭代器依赖于集合
                                                
                                                Iterator iterator=list.iterator();
                                                        while(iterator.hasNext()){
                                                                System.out.print(iterator.next()+",");
                                                        }
                                                3.增强for
                                                for (int i : arr) {
                                                system.out.println(i);
                  set集合特点
                            1无序(存储和读取的顺序有可能不一样)
                                        2.不允许重复(要求元素唯一)
                                        3.没有索引
                collections: 面试题：Collection和Collections有什么区别？
                                                        Collection是集合体系的最顶层，包含了集合体系的共性
                                                        Collections是一个工具类，方法都是用于操作Collection
                                static void swap(List list, int i, int j) :将指定列表中的两个索引进行位置互换
                                static void  sort(List<T> list) :按照列表中元素的自然顺序进行排序
                           Collections.sort(list);
                                static void shuffle(List list):傻否，随机打乱集合中元素的顺序
                                static void reverse(List list)  :反转集合中的元素
                                static void fill(List list, Object obj) :使用指定的对象填充指定列表的所有元素
                                static void copy(List dest, List src) :是把源列表中的数据覆盖到目标列表
                                static int  binarySearch(List list, Object key) 使用二分查找法查找指定元素在指定列表的索引位置
                  
                  
                  MAP:
                  格式:        Map<String , String> map=new HashMap<>();
                  
                  将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
                  键可以重复值不可以重复
                  Map的常用功能：
                                 *                 映射功能：
                                 *                                  V put(K key, V value)
                                 就是key映射到value,如果key存在,就覆盖value,如果不存在将原来的value返回
                                 *                 获取功能：
                                 *                                 V get(Object key) 根据指定的key返回对应的value
                                 *                                 int size() 返回对应关系的个数
                                 *                 判断功能：
                                 *                                 boolean containsKey(Object key) :判断指定key是否存在
                                                                boolean containsValue(Object value) 判断指定的value是否存在
                                                                boolean isEmpty() 判断是否有对应关系
                                 
                                 *                 删除功能：
                                 *                                 void clear()  清空所有的对应关系  
                                 *                                 V remove(Object key)  根据指定的key删除对应关系，并返回key所对应的值，如果没有删除成功则返回null
                                 *
                                 *                 遍历功能：
                                 *                                 Set<Map.Entry<K,V>> set=map. entrySet() ;
                                               获取方式:
                                                           for(entry<k,y> entry:set){
                                                                     String  key=entry.getKey();//直接获取
                                                     String  vaule=entry.getValue();
                                 *
                                                           * }
                                 *                         Set<K> keySet()  :set<string > key=map.keySet();
                                        获取方式: String value=map.get(key);//赋值获取值
                                 *                         Collection<V> values()  :Collection<String> values = map.values();
                                 
                                 对象实现排序的2种方式
                                        1 元素具有排序功能，元素实现Comparable接口，重写compareTo(T o)方法
                                        2 使用比较器，让集合自身具备比较功能
                                                定义一个类作为比较器实现Comparator接口，重写compare(T o1,T o2)方法，把此比较器对象传递给TreeSet
                                        重写方法返回值作用，当前元素与传入元素比，从小到大
                                                返回<0：当前元素比传入元素小，当前对象小于指定对象
                                                返回=0：当前元素与传入元素相等，当前对象等于指定对象，不存
                                                返回>0：当前元素比传入元素大，当前对象大于指定对象
                                                

                                 
                                 异常的体系结构: A: 编译时期异常:是Exception的子类，非RuntimeExcpetion的子类，在编译时期必须处理
                                                                B:RuntimeException和他的所有子类异常,都属于运行时期异常。NullPointerException,ArrayIndexOutOfBoundsException等都属于运行时期异常.
                                                                运行时期异常的特点:
                                                                方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常
                                                                运行时期异常一旦发生,需要程序人员修改源代码.
                                      throwable(最顶层)
                                               nullPointerException
                                                           ArrayIndexOutofboundException
                                                           
                                        2.1Throwable常用方法
                                        String getMessage()  返回此 throwable 的详细消息字符串
                                        String toString()  返回此 throwable 的简短描述
                    void printStackTrace()  打印异常的堆栈的跟踪信息
                                如果出现异常我们没有处理,jvm会帮我们进行处理,他会把异常的类型,原因还有位置显示在命令行
                                并且终止了程序异常后面的代码不在执行
                                异常处理方式:  throws 关键字
                                      捕获
                                             try...catch语句
                                                 try：该代码块中编写可能产生异常的代码。
                                                 catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
                                                         e.printStackTrace();该方法知识将异常信息以system.err错误输出流打印到控制台,并不会终止程序
                                                 finally:组合try...catch使用
                                                
                                                  try{
                                                          有可能发生异常的代码
                                                          //放在这里
                                                  }catch(异常类型 异常对象名){
                                                          对异常进行处理的代码
                                                  }finally{
                                                          //一定会被执行的语句
                                                           例子:public class ExceptionDemo4 {
                                                           public static void main(String[] args) {
                                                        
                                                               
                                                                try {
                                                                        System.out.println(2 / 0);
                                                                } catch (ArithmeticException e) {
                                                                        // TODO Auto-generated catch block
                                                                        e.printStackTrace();
                                                                }
                                                                system.out.println("hello")
                                                        }
                                                         
                                                         
                           多异常处理: try {
                                                // 可能发生异常的代码
                                                } catch (异常类型1 异常对象名1) {
                                                // 处理异常1的代码
                                                } catch (异常类型2 异常对象名2) {
                                                // 处理异常2的代码
                                                }
                                                // 格式
                                                        try {
                                                        // 可能抛出异常的代码
                                                        } catch (异常类型1 | 异常类型2 异常变量名) {
                                                        // 异常处理代码
                                                        if (异常变量名 instanceof 异常类型1) {
                                                        // 处理异常类型1
                                                        } else if (异常变量名 instanceof 异常类型2) {
                                                        // 处理异常类型2
                                                        }
                                                        }
                         // 一般这样处理是因为2种异常的处理方式相同, 才合并写; 否则可以使用catch语句方式分别处理
                        finally概述和引用场景
                                                        finally关键字
                                                        作用:
                                                        与try...catch配合, 无论异常是否被捕获, 最终都会执行finally代码块中的代码
                                                  }
                                                
                        异常的分类
                                                        异常的分类
                                                        编译时异常: 编译时就发生的异常
                                                        Exception 及其子类(除RuntimeException体系)
                                                        处理方式: 编译时期必须处理(try...catch或throws)
                                                        运行时异常: 编译时正确, 但运行时发生的异常
                                                        RuntimeException 类及其子类
                                                        处理方式: 编译时期可以自由选择处理或不处理
                                                        
                        自定义异常
                                                自定义异常
                                                自定义编译时异常类:
                                                定义一个类, 继承 Exception 或其子类(非RuntimeException), 重写构造方法
                                                自定义运行时异常类:
                                                定义一个类, 继承 RuntimeException 或其子类, 重写构造方法
                                                使用自定义异常的方式:
                                                使用编译时异常:
                                                在方法声明上, 使用 throws 抛出 Exception 或其子类的类型(除RuntimeException体系)
                                                使用运行时异常:
                                                在方法内部的代码中, 使用 throw (注意没有s)抛出 RuntimeException 或其子类的对象
                                                throws和throw的区别:
                                                throws : 用于抛出编译时异常, 在方法声明上使用
                                                throw : 用于主动抛出运行时异常, 在方法中使用
                                                        
                递归: 必须定义一个方法    然后方法自己调用自己
                                       
                                          

---

作者: 金色的程序员    时间: 2018-4-14 19:06
整理得不错

---

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

黑马程序员IT技术论坛 X3.2