黑马程序员技术交流社区

标题: [成都校区] [打印本页]

---

作者: 白菜蔡    时间: 2018-12-12 14:39
标题: [成都校区]
        Object超类
object类的tostring方法就是打印对象的地址值(默认方法),所以我们需要在创建对象中
重写object类的tostring方法.(打印对象的属性)
打印对象名字其实就是调用对象的tostring方法.

object类的equals方法比较的是对象的地址值是否相等
所以可以自己创建对象重写equals方法.

        Date类
Date:空参数构造方法=>Date()获取当前系统日期和时间;
Date date = new Date();
有参数构造方法=>Date(Long date)参数是传递毫秒值,把毫秒转换为date日期
Date date = new Date(0L);==>就是1970-01-01 08:00:00;

成员方法:Long gettime(); 把日期转换为毫秒
Date date = new Date();
long time = date.gettime();

DateFormat:日期格式化
抽象类,所以无法直接使用

SimpleDateFormat:是DateFormat的子类
构造方法只有有参构造
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String format(Date date)   传入日期对象转换为字符串
String str =sdf.format(date)

Date parse(String source)  传入字符串转换为日期对象
Date date =sdf.parse("XXX")

         Calendar日历类
Calendar是一个抽象类 不能直接创建对象
只能通过静态方法getInstance来创建对象
Calendar c =Calendar.getInstance();

int i =c.get(Calender.YEAR)==>获取年份
c.set(Calender.YEAR,2022)==>设置成2022年
c.add(Calendar.YEAR,2)==>加2年
Date date =c.getTime();==>把日历对象转换为日期对象

        System类
System.arraycopy(源数组,源数组开始位置,目标数组,目标数组开始位置,元素个数);

        Stringbuilder类:字符串缓冲区
空参构造方法:Stringbuilder bu =new Stringbuilder()

有参构造方法:Stringbuilder bu1 = new Stringbuilder("itcast"):把string转换成Stringbuilder
Stringbuilder转换成string :可以用tostring方法
Stringbuilder类重写了tostring方法

成员方法:append();
链式编程:bu.append("abc").append("def").appe("qqq") 返回的是自身

字符串转换成基本数据类型:
int i = Integer.parseInt(String str);==>字符串转化成数字
        Collection集合
Collection集合是所有单列集合最顶层的接口;
顶层不是接口就是抽象类,无法创建对象使用,需要使用底层的子类创建对象使用
顶层分为:list接口:有序的集合,允许存储重复元素,有索引
        set接口:不允许存储重复元素,没有索引
底层:Hashset集合:无序的集合.linkedHashset有序的集合


Collection使用:
创建Collection对象(使用多态)
Collection<String> coll = new ArrayList<>();

coll.add(参数)集合添加功能,返回布尔值,一般不接收返回值
coll.remove(参数)集合删除元素,有重复的只会删除第一个.返回布尔值
coll.contains(参数)判断集合中是否包含参数,返回布尔值.
coll.isEmpty()判断集合是否为空;集合为空返回true 不为空返回false;
coll.size()获取集合中的个数,返回整数int类型.
coll.toArray()把集合中的元素存储到数组中,返回的是object[]
coll.clear()清空集合的元素/没有返回值.不会把集合删除.

        Iterator<E>迭代器
作用:Collection集合的通用获取方式.对集合进行遍历
格式:
Collection<E> coll = new ArrayList<>();
Iterator<E> it = coll.iterator();
while(it.hasNext()){
        Object s= it.next()
}

迭代器的并发修改异常解决办法:
1,在迭代的过程中,不对集合的长度进行修改
2.iterator接口有一个子接口Listiterator(只有list接口下面的才可以使用)
List<String> coll = new ArrayList<>();
ListIterator<String> lit = coll.listIterator();
lit.add("xxx");
就不会出异常

        泛型
E e:element元素
T t:type 类型

定义含有泛型的类:
public class Test<E>{
        private E name;
}
Test<String> t = new Test()

定义含有泛型的方法:
格式:
修饰符<泛型> 返回值类型 方法名(参数列表(使用泛型)){}
传递什么类型的参数,泛型就是什么类型

public <M> void method(M m){}

public static <S> void method2(S s){}

泛型通配符就是:<?>
数据结构_栈:先进后出:入口和出口都在同一侧.
数据结构_队列: 先进先出:两个口子

数组:查询快,增删慢

链表:查询慢.增删快

红黑树:特点:趋近于平衡树,查询速度特别快,查询叶子节点最大次数和最小次数不超过2倍
约束:根节点是黑色的

        List集合
List (extends Collection)集合:有序,有索引,可以重复
常用方法:(LIst特有的)
        void add(index,element):将指定元素添加到指定位置
        E get(index):返回集合指定位置元素
        E remove(index):移除列表中指定位置的元素,返回删除的元素
        E set(index,element):用指定的元素替换指定的位置上的元素,返回被替换的元素
       
        LinkedList集合(List接口的实现类)
LinkedList特点:是一个双向链表:查询慢(除了首尾),增删快,里边包含了大量操作首尾的元素的方法
注意:LinkedList集合不能使用多态.

        void addFirst(E e)        集合开头添加元素
        void addLast(E e)        集合末尾添加元素 等效于add()方法
        void push(E e)        等效于addFirst方法

        E getFitst()        获取第一个元素并返回元素
        E getLast()        获取最后一个元素并返回元素

        E removeFirst()        移除第一个元素并返回元素
        E removeLast()        移除最后一个元素并返回元素
        E pop()        等效于removeFirst(E e)并返回元素

        boolean isEmpty()   判断集合是否包含元素


        Vector集合(所有单列集合的祖宗)
Vector底层也是数组
单线程 速度慢,所以被Arraylist取代了

        Set集合(和List平级)
set(extends Collection)特点:无序 ,不可重复元素,没有索引
Set集合判断是否重复的原理是:判断Hashcode和equals是否相同

        HashSet(是Set的实现类)
特点:无序(不代表随机) ,不可重复元素,没有索引,底层是一个哈希表结构(查询非常快)
遍历不能用for循环 用迭代器(增强for)循环遍历
存储自定义类元素必须要重写hashcode和equals方法

        LinkedHashSet集合(是HashSet的子类)
特点:有序,不可重复元素,没有索引
底层是:哈希表(数组+链表/红黑树)+链表(多一条链表记录元素存储顺序),所以有序的

        可变参数
使用前提:当方法的参数列表数据类型已经确定,但是参数个数不确定就可以使用可变参数

格式: 定义方法是使用:修饰符 返回值类型 方法名(数据类型...变量名){}
public static void method(Object...obj){}

原理:底层是一个数组,根据传递参数个数不同,会创建不同程度的数组
传递的参数个数,可以是0个(不传递),1,2...多个
注意事项:一个方法的参数列表,只能有一个可变参数
        如果方法有多个参数,可变参数必须写在末尾

        Collections集合工具类
boolean addAll(Collection(T) c,T... elements)往集合中添加元素
void shuffle(List<?> list)打乱集合顺序
void sort(List<T> list)  排序方法按照默认(升序)规则排序
自定义对象必须实现Comparable接口,重写compareTo方法  才能使用sort方法
自定义比较规则:比较两个人的年龄(this,参数person)=升序排序=>return this.getAge() - o.getAge()(反之降序)

static <T> void sort(List<T> list,Comparator<? super T>)排序方法
Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int result =o1.getAge()-o2.getAge();
                if(result ==0){
                    result =o1.getname().charAt(0)-o2.getname().charAt(0)
                }return result;
            }
        });
        Map<k,v>集合
Map集合的特点:
1.Map是一个双列集合,一个元素包含两个值(一个key,一个value)
2.Map集合中的元素,key和value的数据类型可以相同,也可以不同
3.Map集合中的元素,key不允许重复,valu可以重复
4.Map集合中的元素,key和valu是一一对应的

        Map常用子类
HashMap:不同步,多线程
特点:
1.底层是哈希表,查询速度特别快
2.hashMap集合是一个无序的集合

LinkedHashMap:extends HashMap集合
特点:        有序的(底层是哈希表加链表)

        Map常用方法
V put(key ,value) 把指定的键与值添加到Map集合中,返回值是value
存储的时候:key不重复,返回值是null
        key重复,会使用新的value替换,返回被替换的value

V get(key)通过key找到value
        key存在,返回对应的值
        key不存在,返回null;

V remove(key)通过key删除value 返回被删除的
把指定的key所对应的值在map中删除,
        key存在:返回被删除的值
        key不存在,返回null;

boolean containsKey(key):包含key返回true,不包含,返回false.

Set<K> keyset() 用来遍历map集合,返回值是set集合里面装的是所有的key值
在循环(迭代器/增强for)遍历通过key找到value值
实现步骤:
1.使用map集合中的方法keyset(),把map集合所有的key取出来,存储到set集合中
2.通过set集合,获取map中的每一个key
3.通过map集合的方法get(key),找到每一个value

Set<Map,Entry<K,V>> entryset()
实现步骤:
1.使用map集合中的方法entryset(),把集合中多个Entry对象取出来,放到set集合中
2.遍历set集合,获取每一个Entry对象
3.使用Entry对象中的getkey(),getvalue方法获取键与值

        Entry键值对对象
getkey:获取key
getvalue:获取value

        HashMap存储自定义对象键值
保证key是唯一的:作为key元素必须重写hashcode和equals方法,保证key唯一

        LIinkedHashMap集合extends HashMap
和HashMap用法相同,区别为LIinkedHashMap是有序的.

        Hashtable<K,V>集合
底层是一个哈希表,线程安全的集合,单线程速度慢
不能存储null对象,之前学的所有集合都可以存null
Hashtable<K,V>和Vector在jdk1.2之后被更先进的集合取代了
Hashtable的子类Properties依然活跃在历史舞台.
        异常体系
Throwable:
1.Error  :工程师不能修复,只能改源代码

2.Exception:由于使用不当导致,可以避免的

try catch / finally/throw/throws

        throw关键字,写在方法内部,我们自己抛异常,可以自定义异常信息
作用:可以使用throw关键字在指定的方法中抛出指定的异常
格式:throw new XXXException("异常产生的原因");
注意:
1.throw关键字必须写在方法的内部
2.throw关键字后边new的对象必须是Exception或者Exception子类的对象
3.throw关键字抛出指定的异常对象,我们就必须处理这个异常对象
        throw关键字后边创建的是RuntimeException或者是
RuntimeException的子类,我们可以不处理,默认交给JVM处理
        throw关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws要么try...catch...


        Objects的非空判断
objects.requireNonNull(obj);
objects.requireNonNull(obj,"异常产生原因");

        throws关键字,写在方法上,JVM帮我们抛异常.使用默认的异常信息
注意:
1.throws关键字后边声明的异常必须是Exception或者是Exception子类
2.方法内部认购抛出了多个异常对象,那么throws后边也必须声明多个异常
        如果抛出的多个异常有子父类关系,那么直接声明父类异常即可
3.调用了一个声明抛出异常的方法,必须处理声明的异常
        要么继续使用throws声明抛出,交给调用者处理,最终交给JVM
        要么try...catch自己处理异常

        try...catch
格式:        try{
        可能产生异常的代码
        }catch(定义一个异常的变量,用来接收try中抛出的异常对象){
        异常的处理逻辑(一般在工作中,会把异常的信息记录到一个日志中)
        }
        ...
        catch(){}
注意:
1.try中可能抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
2.如果try中产生了异常,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,继续执行try...catch之后的代码
如果try中没有产生异常,那么就不会执行catch中异常的逻辑,执行完try中代码,继续执行try...catch之后的代码

        finally代码块:配合try...catch使用
注意:不能单独使用
一般用于资源释放,资源回收,无论程序是否出现异常,最后都要资源释放

        自定义异常类
格式:public class XXXException extends Exception \ RuntimeException{
        添加一个空参数构造方法
        添加一个带异常信息的构造方法
        }

注意:
1.自定义异常类名一般都是以Exception结尾,说明该类是一个异常类
2.自定义异常类,必须继承Exception或者RuntimeException
        继承Exception:那么自定义异常类是一个编译期异常,如果方法内部抛出了编译期异常,
就必须处理这个异常,要么throws/要么try...catch
        继承RuntimeException:那么自定义的异常就是一个运行期异常.无序处理,交给JVM处理

        线程
格式:1.创建Thread类的子类,2.重写run()方法,设置线程任务
使用:创建类对象,调用start()方法
        Thread类
常用方法:
getname();  ==>获取线程的名称,返回值是String
用法:直接调用方法.

currentThread(); ==>获取当前正在执行的线程,在使用.getname可以获得线程对象的名称
用法:Thread.currentThread().getname();

Thread.sleep(毫秒值);==>让线程睡一下

        Runnable接口
实现步骤:
1.创建Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法.设置线程任务
3.创建一个runnable接口的实现类对象
4,创建一个thread类对象,构造方法中传递runnable接口的实现类对象
5.调用thread类中的start方法,开启多线程

解决线程安全的问题,有以下几种办法:
        同步代码块
格式:synchronized(锁对象){需要同步操作的代码}

        同步方法
格式:修饰符 synchronized 返回值类型  方法名(参数列表){代码...}

        lock锁接口
        实现类Reentrantlock
使用步骤:
1.在成员位置创建一个Reentrantlock对象
Lock l = new Reentrantlock();
2.在可能会出现安全问题的代码前调用lock接口中的方法lock()获取锁
3.在可能会出现安全问题的代码后调用lock接口中的方法unlock()释放锁

---

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

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