day13Calendar类、System类、StringBuf

2020-07-28 本文已影响0人 __method__

Calendar类

Calendar是抽象类，由于语言的敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象。
使用默认时区和语言环境获得一个日历

Calendar calendar = Calendar.getInstance();

常用方法

public int get(int field); 返回给定日历字段的值

public class TestCalendar {
    public static void main(String[] args) {
        // 创建calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar);
        // 设置年
        int year = calendar.get(Calendar.YEAR);
        // 设置月
        int month = calendar.get(Calendar.MONTH) + 1;
        // 设置日
        int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH) ;


        System.out.println(year+"年"+month+"月"+dayOfMonth+"日"); // 2020年7月28日
    }
}

public void set（int field， int value）将给定的日历字段设置为给定的值

public class TestCalendar2 {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;
        int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH) ;
        System.out.println(year+"年"+month+"月"+dayOfMonth+"日"); // 2020年7月28日
        calendar.set(Calendar.YEAR, 2021);
        year = calendar.get(Calendar.YEAR);
        month = calendar.get(Calendar.MONTH) + 1;
        dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH) ;
        System.out.println("set之后");
        System.out.println(year+"年"+month+"月"+dayOfMonth+"日"); // 2020年7月28日
    }
}

public abstract void add（int field， int amount）：根据日历的规则，为给定的日历字典添加或减去指定的时间量

public class TestCalendar3 {
    public static void main(String[] args) {
        Calendar calendar=Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH)+1;
        int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(year+"年"+month+"月"+dayOfMonth+"日");//2020年7月28日

        calendar.add(Calendar.DAY_OF_MONTH,2);
        calendar.add(Calendar.YEAR,-3);
        year = calendar.get(Calendar.YEAR);
        month= calendar.get(Calendar.MONTH)+1;
        dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println("add之后");
        System.out.println(year+"年"+month+"月"+dayOfMonth+"日");

    }
}

public Date getTime(): 返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date 对象。

public class TestCalendar4 {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        Date date = calendar.getTime();
        System.out.println(date); // Tue Jul 28 09:13:15 CST 2020

        Date date1 = new Date();
        System.out.println(date1); // Tue Jul 28 09:13:15 CST 2020
    }
}

案例获取当月的最后一天

public class TestCalendar5 {
    public static void main(String[] args) throws Exception {
        // calendar.getActualMaximum();// 获取给定日历的最大可能值
        String lastDayOfMonth = getLastDayOfMonth("2020-06");
        System.out.println(lastDayOfMonth);
        int lastDay = lastDay(2020, 07);
        System.out.println(lastDay);
    }
    /**
     * 编写一个方法， 根据给定字符串yyyy-MM获取当月的最后一天
     */
    public static String getLastDayOfMonth(String yearmonth) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        Date date = sdf.parse(yearmonth);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int lastDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        return "" + lastDay;
    }
    public static int lastDay(int year, int month){
        Calendar calendar = Calendar.getInstance();
        calendar.clear(); // 清除所有日期数据
        calendar.set(Calendar.YEAR, year);
        calendar.set(Calendar.MONTH, month - 1);
        int lastDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        return lastDay;
    }
}

System类

是java.lang包下的类，提供大量的静态方法，可以获取与系统相关的信息或者系统级操作，常用方法有：

System.currentTimeMillis() 获取当前系统时间与1970年1月1日00点00分之间的毫秒值

public class TestSystem {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis()); // 1595902107023
    }
}

练习：
验证一下 for循环打印 1~9999需要的时间

public class TestSystem1 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 9999 ; i++) {
            System.out.print(i);
        }
        System.out.println();
        long end = System.currentTimeMillis();
        System.out.println("耗时" + (end -start));
    }
}

arrayCopy 将数组中指定的数据拷贝到另一个数组中

public class TestSystem2 {
    public static void main(String[] args) {
        // 将 src 中前 3个元素， 赋值到dest的前3个位置上复制元素前
        //  操作之后： [1, 2, 3, 4, 5]  dest [1, 2, 3, 9, 10]
        int[] src = new int[]{1, 2, 3, 4, 5};
        int[] dest = new int[]{6, 7, 8, 9, 10};
        System.arraycopy(src, 0, dest, 0, 3);
        System.out.println(Arrays.toString(dest));
    }
}

StringBuilder类

由于String对象的不可变，字符串在拼接式，总会创建新的对象，字符串是常量，它的值在创建之后不能修改，如果对字符串进行频繁的操作，每次都会创建新的String对象，既耗时，又浪费空间，为了解决这一问题，可以使用java.lang.StringBuilder。

StringBuilder又称为可变字符序列，通过某些方法调用可以改变该序列的长度和内容。

构造方法：

pulic StringBuilder()
pulic StringBuilder( String str)

append方法

public class TestStringBuilder1 {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder();
        StringBuilder builder1 = builder.append("hello");
        System.out.println("builder = "+ builder);
        System.out.println("builder1 = "+ builder1);
        System.out.println(builder == builder1);// true
        // 可以添加 任何类型
//        builder.append("啥呀");
//        builder.append("world");
//        builder.append(true);
//        builder.append(1000);
        // 在我们开发中， 会遇到调用一个方法后， 返回一个对象的情况，
        // 然后使用返回的对象继续调用方法
        // 这种我们可以使用链式编程的方式
        builder.append("haha").append("哈哈").append(true).append(1212);
        System.out.println("builder = "+ builder);


    }
}

toString方法

通过toString方法, StringBuilder对象将会转换为不可变的String对象

三者区别

包装类

Java提供两种类型系统，基本类型和引用类型。使用基本类型在于效率，然而很多情况会创建对象使用，因为对象可以做更多的事，也就有了对应的包装类。

装箱和拆箱
基本类型和对应的包装类来回转换的过程、
装箱：基本到包装
拆箱：包装到基本

public class BaoZhuangDemo {
    public static void main(String[] args) {
        Integer i = new Integer(4); // 基本 ===》 包装
        int i1 = i.intValue(); // 包装变 基本
    }
}

自动装箱和自动拆箱
基本类型和包装类的装箱和拆箱可以自动完成

Integer i = 5;// 自动装箱，
i = i + 5; // 自动拆箱
int a = 100;
System.out.println("a的值" + a);

基本类型和字符串之间的转换

public class Demo {
    public static void main(String[] args) {
        // "123"  123
        // 基本类型转换为String类型
        int a = 100;
        String b = "" + a;
        System.out.println(b);
        // String 类型转换为基本类型
        // 包装类都有parseXxx静态方法可以将字符串参数转换为对应的基本类型
        int i = Integer.parseInt("120");
        Integer integer = Integer.valueOf("120");
        System.out.println(i);
        System.out.println(integer);
    }
}

Collection集合

集合：集合是java中提供的一种容器，可以用来存储多个数据
与数组的区别：
数组的length固定，集合可变
数组中存储的是同一类型的元素，集合存储的都是对象，而且对象的类型可不一致，当开发中当对象多的时候，使用集合进行存储。

集合分类

按照存储结构分为两大类

单列集合 java.util.Collection
双列集合 java.util.Map

Collection 单列集合类的根接口，它有两重要的子接口

java.util.List 特点：元素有序，可以重复，主要实现类，ArrayList，LinkedList
java.util.Set 特点：元素无序，不可以重复，主要实现类，HashSet，TreeSet

Collection 常用功能

主要方法：

public boolean add(E e) , 把给定的对象元素e添加到集合中
public void clear() , 清空集合中所有的元素
public boolean remove(E e)；把给定的对象元素e从集合中删除
public boolean contains(E e)；判断集合中是否包含给定的元素
public boolean isEmpty()；判断当前集合是否为空
public int size()；返回集合中元素的个数
public Object[ ] toArray()；把集合中的元素返回为 Object[ ]数组

public class TestCollection {
    public static void main(String[] args) {
        // 使用多态形式创建集合对象
        Collection<String> coll = new ArrayList<>();
        // add
        coll.add("小鲁班");
        coll.add("后羿");
        coll.add("安琪拉");
        System.out.println(coll);
        // contains(E e)；判断集合中是否包含给定的元素
        System.out.println(coll.contains("小鲁班")); // true
        System.out.println(coll.contains("王昭君")); // false

        // remove(E e)； 把给定的对象元素e从集合中删除
        System.out.println(coll.remove("小鲁班")); // remove
        System.out.println("删除之后"+ coll);
        // isEmpty()； 判断当前集合是否为空
        System.out.println(coll.isEmpty()); // false
        // size()；返回集合中元素的个数
        System.out.println(coll.size()); // 2
        Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        //clear() , 清空集合中所有的元素
        coll.clear();
        System.out.println(coll);
    }
}

Iterator接口

在程序开发中我们经常要遍历集合中所有的元素，针对这种需求JDK提供java.util.Iterator， Iterator也是Java集合的一员，它与Collection 和Map不同， Collection 和Map是存储元素的， Iterator是用于迭代访问(即遍历)Collection 中的元素， Iterator 又被称为迭代器.
Collection 中：

Iterator 常用方法：

boolean hasNext(); 如果仍然有元素可以迭代，返回true
E next(); 返回迭代的下一个元素

增强for循环

增强for循环（也称foreach循环）是jdk1.5之后出现的高级for循环，专门用来遍历数组和集合的，内部原理实际上是一个迭代器，不能对集合中的元素进行增删操作
格式：

for（元素的数据类型  变量 ： 集合或数组）{
      // 操作代码
}

简单记忆格式

for(  当前取出的值 :  我要迭代谁){
      // 当前取出的值
}

举例

public class TestForEach {
    public static void main(String[] args) {
        int[] arr = {1, 4, 6, 7, 8};
        for (int  a: arr){
            System.out.println(a);
        }
        Collection<String> coll = new ArrayList<>();
        coll.add("小鲁班");
        coll.add("后羿");
        coll.add("安琪拉");
        for(String hero :coll){
            System.out.println("当前英雄是"+hero);
        }
    }
}

斗地主发牌案例

package com.neusoft.day13.doudizhu;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**
 * @author Eric Lee
 * @date 2020/7/28 16:15
 * 斗地主 的洗牌和发牌动作
 *  规则： 使用54张牌打乱顺序， 三个玩家参与游戏， 每人17张牌 最后剩三张底牌
 *  - 准备牌： 每张牌由花色和数字组成
 *  - 发牌
 *  - 看牌
 */
public class Poker {
    public static void main(String[] args) {

        // 准备牌： 每张牌由花色和数字组成
        // 创建牌盒, 存储牌
        List<String> pokerBox = new ArrayList<>();
        // 创建数字集合
        List<String>  numbers = new ArrayList<>();
        // 创建花色集合numbers
        List<String> colors = new ArrayList<>();
        // 添加花色
        colors.add("♥");
        colors.add("♦");
        colors.add("♠");
        colors.add("♣");
        for (int i = 2; i <= 10 ; i++) {
            numbers.add(i+"");
        }
        numbers.add("J");
        numbers.add("Q");
        numbers.add("K");
        numbers.add("A");
        // 生产牌， 拼接花色和数字
        for(String color: colors){
            // 每次拿到一种花色
            for(String number :numbers){
//                String card = color + number;
//                pokerBox.add(card);
                pokerBox.add(color+number);
            }
        }
        pokerBox.add("大王");
        pokerBox.add("小王");
        //  System.out.println(pokerBox);
        // 洗牌: Collections 工具类 都是静态方法
        // shuffle() 使用默认随机元对指定列表进行置换
        Collections.shuffle(pokerBox);
        //   System.out.println(pokerBox);
        // 发牌 创建player1、player2、player3、dipai底牌4个集合
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();
        for (int i = 0; i < pokerBox.size(); i++) {
            String card = pokerBox.get(i);
            // 判断i值，先判断
            if(i >= 51){
                dipai.add(card);
            }else {
                if(i%3==0){
                   player1.add(card);
                }else if (i%3==1){
                    player2.add(card);
                }else {
                    player3.add(card);

                }
            }
        }

        // look look
        System.out.println("王思聪的牌"+ player1);
        System.out.println("马云的牌"+ player2);
        System.out.println("我的牌"+ player3);
        System.out.println("底牌"+ dipai);

    }

}