day13常用API2Calendar、System类、StringBuilder、StringBuiffer、包装类、Collection集合

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 day = calendar.get(calendar.DAY_OF_MONTH);
        System.out.println(year + "月" + month + "月" + day + "日");

    }
}
  • 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包下的类，提供大量的静态方法，可以获取与系统相关的信息或者系统级操作，常用方法有;

  • 1.System.currentTimeMillis() 获取当前系统时间与1970年1月1日00点00分之间的毫秒值
public class TestScanner {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis()); //1595902117467
    }
}

练习：
验证一下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));

    }
}

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


public class TestSystem2 {
    public static void main(String[] args) {
        //将src中前三个元素，赋值到dest的前三个位置上复制元素前
        //操作之后：[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又称为可变字符序列，通过某些方法调用可以改变该序列的长度和内容。

构造方法：

  • public StringBuilder()
  • public 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 integer = new Integer(4); //基本====》包装
        int i = integer.intValue();  //包装变基本
    }
}
  • 自动装箱和自动拆箱
    基本类型和包装类的装箱和拆箱可以自定义完成
//        Integer integer = new Integer(4); //基本====》包装
//        int i = integer.intValue();  //包装变基本
        Integer i = 4;   //自动装箱
        i = i + 4; //自动拆箱
        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 = " " + 100;
        System.out.println(b); //字符串100
        //String 类型转换为基本类型
        //包装类都有parseXxx静态方法可以将字符串参数转换为对应的基本类型
        int c = Integer.parseInt("120");
        System.out.println(c);
        Integer d = Integer.valueOf("133");
        System.out.println(d);
    }
}

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 contain(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);
        // contain(E e);判断集合中是否包含给定的元素
        System.out.println(coll.contains("小鲁班")); //true
        System.out.println(coll.contains("王昭君"));//false
        // remove(E e);把给定的对象元素e从集合中删除
        System.out.println(coll.remove("小鲁班")); //true
        System.out.println("删除之后" + coll);
        // isEmpty();判断当前集合是否为空
        System.out.println(coll.isEmpty()); //false
        // size();返回集合中元素的个数
        System.out.println(coll.size()); //2
//        Object [ ] toArray();把集合中的元素返回为Object[ ]类型的数组
        Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.print(objects[i] + "\t");
        }
        System.out.println();
        //clear() 清空集合中所有的元素
        coll.clear();
        System.out.println(coll);


    }
}

Iterater接口

在程序开发中我们经常要遍历集合中所有的元素,针对这种需求JDK提供Java.util.iterater也是Java集合的一员，，它与Collection和Map不同，Collection和Map是存储元素的，Iterater适用于迭代访问（即遍历）Collection中的元素，Iterater又被称为迭代器。
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<>();
        //add
        coll.add("小鲁班");
        coll.add("后羿");
        coll.add("安琪拉");
        for (String hero : coll) {
            System.out.println("当前英雄" + hero);
        }
        
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。