Java学习笔记4

1:自动装箱和拆箱

装箱:把基本数据类型转换为对应的包装类类型

Integer i = Integer.valueof(100); //装箱
Integer ii = 100; //自动装箱，也做了装箱的动作，只不过看不到，简化了步骤。

拆箱:把包装类类型转换为对应的基本数据类型

ii = 100；
ii = ii.intvalue()+200; //手动拆箱，
// ii.intvalue()这个操作称为拆箱。
ii += 200；//ii+200自动拆箱，ii=ii+200自动装箱。

注：在使用包装了类型时，要判断是否为null。

Integer a = null;
a += 100;

会报错，因为a += 100中包含了a.intvalue()的拆箱，null后不能加方法，
改正方法：加一个判断：

Integer a = null;
if(a != null){
    a += 100;
}

2：Date类

构造方法：
public Date() 分配一个Date对象，并初始化，精确到毫秒。
public Date(long date) 分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

public class DateDemo{
    public static void main(string[] args){
        Date d1=new Date();
        system.out.println(d1);

        long date = 1000*60*60
        Date d2= new Date(date);
        system.out.println(d2);
    }
}

常用方法：
public long getTime() 获取从1970.1.1的00:00:00到现在的毫秒值
public void setTime(long time) 设置时间，毫秒值

Date d=new Date();
System.out.println(d.getTime()*1.0/1000/3600/24/365+"年");
long time = 1000*60*60
d.setTime(time) ;
System.out.println(d);

3：SimpleDateFormat类

日期和时间格式由日期和时间模式字符指定，从A-Z，a-z引导的字母被解释为表示日期或时间字符串的组件的模式字母。
常用：y–年，M–月，d–日，H–时，m–分，s–秒
构造方法：

public SimpleDateFormat() 构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattren) 构造一个SimpleDateFormat使用给定的模式和日期格式。

SimpleDateFormat格式化和解析日期。
1：格式化：从Date到String
public final String format(Date date); 将日期格式化成日期/时间字符串
2：解析：从String到Date
public Date parse(String source); 从给定字符串的开始解析文本以生成日期

 public class SimpleDateFormatDemo{
    public static void main(string[] args){
        //格式化：从Date到String
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat();
        String s = sdf.format(d);
        System.out.println(s);
        //解析：从String到Date
        String ss = "2020-08-08 10:10:10";
        SimpleDateFormat sdf2 = new SimpleDateFormat(pattern:"yyyy-MM-dd HH:mm:ss");// 这里的格式要和前面的格式互相对应
        Date dd = sdf2.parse(ss);
        System.out.println(dd);
    }
}

4:Calendar类

Calendar为某一时刻和一组日历字段之间的转换提供了方法,并为操作日历字段提供了一些方法 Calendar提供了一个类方法
getInstance用于获取Calendar对象，已使用当前日期和时间初始化:

Calendar rightNow = Calendar.getInstance(); //初始化

public class CalendarDemo{
    public static void main(string[] args){
        //获取对象
        Calendar c= Calendar.getInstance();
        //获取年月日
        int year = c.get(Calendar . YEAR);
        int month = C. get(Calendar .MONTH) + 1;//注：需要做+1的操作
        int date = c. get(Calendar .DATE);
        //输出日历
        System. out . println(year + "年" + month +月" + date +“日");
    }
}

Calendar的常用方法：

public int get(int field) 返回给定日历字段的值 public abstract vord add(int
field, int amount) 将指定的时间量添加或减去给定的日历 public final void set(int
year,int month,int date) 设置当前日历的年月日

public class CalendarDemo{
    public static void main(string[] args){
        //获取对象
        Calendar c= Calendar.getInstance();
        //获取年月日
        int year = c.get(Calendar . YEAR);
        int month = c. get(Calendar .MONTH) + 1;//注：需要做+1的操作
        int date = c. get(Calendar .DATE);

        //public abstract vord add(int field, int amount)
        //三年前的今天
        c.add(Calendar . YEAR,amount:-3);
        //十年后的五天前
        c.add(Calendar . YEAR,amount:+10);
        c.add(Calendar . DATE,amount:-5);
         
         //public final void set(int year,int month,int date)  
         c.set(year:2020,month:10,date:10);
    }
}

5:异常

异常体系:

Throwable分为Error和Exception
Exception又分为RuntimeException和非RuntimeException Error:严重问题，不需要处理
Exception:异常类，表示程序本身可以处理的问题

●RuntimeException: 在编译期是不检查的，出现问题后，需要我们回来修改代码
●非RuntimeException:编译期就必须处理的,否则程序不能通过编译，就更不能正常运行了

默认处理方案：
●把异常的名称，异常原因及异常出现的位置等信息输出在了控制台
●程序停止执行
1）:try…catch…

try{
    可能出现异常的代码；
}catch(异常类名 变量名){
    异常的处理代码；
}

//try…catch…可以使结果运行下去

2）:throws 异常类名；

注：这个格式跟在方法的口号后面。

Throwable的成员方法

public String getMessage() 返回此throwable的详细消息字符串
public String toString() 返回此可抛出的简短描述
public void printStackTrace() 把异常的错误信息输出在控制台

6：集合：提供一种存储空间可变的存储模型。

集合类体系结构：

集合分为Collection单列和Map 双列
Collection单列分为 List可重复 和Set 不可重复

• List实现类(Arraylist,Linklist,…)
• Set实现类(HashSet,TreeSet,…)
• Map实现类(HashMap,…)

Collection，List，Set，Map都为接口。

7：Collection集合

创建Collection集合的对象
●多态的方式
●具体的实现类Arraylist

public class CollectionDemo {
    public. static void main(String[] args) {
    //创建Collection集合的对象
        Collection<String> c = new ArrayList<String>();
        //添加元素
        c.add("hello");
        c.add("world")；
        System.out.println(c);
    }
}

Collection集合的常用方法

boolean add(E e) 添加元素
boolean remove(Objecto) 从集合中移除指定的元素
void clear() 清空集合中的元素
boolean contains(Object o) 判断集合中是否存在指定的元素
boolean isEmpty() 判断集合是否为空
int size()集合的长度，也就是集合中元素的个数

public class CollectionDemo {
    public. static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        c.add("hello");//添加
        c.remove("hello")//添加
        c.clear();//清除
        System.out.println(c.isEmpty());//检验集合是否为空
        System.out.println(c.size());//返回集合中元素的个数
    }
}

Collection集合的遍历
iterator：迭代器，集合的专用遍历方式。
iterator iterator(): 返回此集合中元素的迭代器，通过集合的iterator()方法得到

iterator中的常用方法
E next() :返回迭代中的下一个元素
boolean hasNext(): 如果迭代具有更多元素，则返回true

Collection<String> c = new ArrayList<String>();
c.add("hello");
iterator<String> it = c. iterator();
System.out.println(it.next());
if(it.hasNext()){
    System.out.println(it.next());
}

8：List集合，有序集合即序列

特点：有序，可重复

public class ListDemo01 {
    public. static void main(String[] args) {
    //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list. add("he1lo");
        list. add("world");
        list. add("java");
        list. add("world");
        System. out . println(list);
        //迭代器的方式遍历
        iterator<String> it = list. iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

List集合的特有方法：
void add(int index,E element) 在集合中指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素，返回被删除的元素
E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
E get(int index) 返回指定索引处的元素

list.add(index:1,element:"hello");
list.remove(index:1);
list.set(index:1,element:"hello");
list.get(index:1);
//遍历list集合
for(int i=0; i<list.size(); i++){
    String s = list.get(i);
    System.out.println(s);
}

并发修改异常:

ConcurrentModificationException

产生原因
●迭代器遍历的过程中 ,通过集合对象修改了集合中元素的长度,造成了迭代器获取元素中判断预期修改值和实际修改值不一致

解决方案
●用for循环遍历,然后用集合对象做对应的操作即可

列表迭代器listIterator
●可延任何方向遍历
●通过List集合的listIterator()得到，是List集合特有的迭代器

Listlterator中的常用方法
●E next():返回迭代中的下一个元素
●boolean hasNext():如果迭代具有更多元素，则返回true
●E previous():返回列表中的上一个元素
●boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
●void add(E e):将指定的元素插入列表

//得到listIterator
ListIterator<String> lit = list.listlterator();
//正向遍历
while(lit.hasNext()){
    String s = lit.next();
    System.out.println(s);
}
//逆向遍历
while(lit.hasPrevious()){
    String s = lit.previous();
    System.out.println(s);
}

增强for循环：简化数组和Collection集合的遍历

格式：
for(元素数据类型 变量名：数组或者Collection集合){
//在此处使用变量即可，
}

举例：

int[] arr={1,2,3,4,5};
for(int i:arr){
    System.out.println(i);
}