java学习第十九天之API、Date、Calendar_addorderexception(string arg0, throwable arg1, boo-CSDN博客

本文链接：https://blog.csdn.net/weiyumeizi/article/details/64940816

Array

package cn.myapi.demo;
public class ArrayDemo {
    /**
    * @param args
    */
    public static void main(String[] args) {
    /*  
        int sum=add(4,5);
        int sum1=add(4,5,6);
    */  
        int[] arr={37,17,21,87};
        int[] arr2={3,5};
        int sum=add(arr);
        int sum2=add(arr2);
        System.out.println(sum);
        System.out.println(sum2);

        int sum3=add(6,7,8);
        System.out.println(sum3);//调用可变参数

    }
/*
    public static int add(int i, int j) {
        return i+j;
    }
    */

/*
    public static int add(int i, int j,int k) {
        return i+j+k;
    }
    */

/*  
    //  简化版
    public static int add(int[] arr) {
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum;
    }
*/  
    public static int add(int... arr) {
        //...代表可变参数，还是数组  弊端add(int... arr,int x)报错  add(int x,int... arr) 运行   可变参数要求一定是最后一个参数
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum;
    }
}

Arrays

package cn.myapi.demo;

import java.util.Arrays;
import java.util.List;

import javax.swing.SpringLayout.Constraints;

public class ArraysDemo {
    /**
    * @param args
    */
    public static void main(String[] args) {
        int[] arr={32,67,1,79,97};
        System.out.println(arr);
        System.out.println(Arrays.toString(arr));

        String[] string={"add","sds","aadd"};
        boolean ans=myContains(string, "add");
        System.out.println(ans);

        /*
        发现集合中本身就有这个方法。contains()
        将数组转成集合，就行了
        用aslist就不用自己写myContains()
        */
        List<String> list=Arrays.asList(string);        
//      list.add("ss");//java.lang.UnsupportedOperationException    注意：不能使用集合的增删方法。不能改变长度
        System.out.println(list.contains("add"));

    /*  
        如果数组中都是引用数据类型，转成集合是，数组元素直接作为集合元素
        如果数组中都是基本数据类型，会将数组对象作为集合中的元素
    */  
        int[] arrs={37,56,23,17};
        List list2=Arrays.asList(arrs);
        System.out.println(list2.get(0));
    }


    public static boolean myContains(String[] arr,String key) {
        for (int i = 0; i < arr.length; i++) {
            String string=arr[i];
            if(string.equals(key))
                return true;
        }
        return false;
    }

    public static <T> void swap(T[] arr, int i, int j) {
        T temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

Calendar

package cn.myapi.demo;

import java.util.Calendar;

public class CalendarDemo {
    /**
    * @param 演示日历 Calendar
    */
    public static void main(String[] args) {
        Calendar calendar=Calendar.getInstance();
        System.out.println(calendar);
        System.out.println("------------------------------");
        calendar.set(Calendar.YEAR, 2016);
        calendar.set(2016, 5, 22);

//      日期的偏移
        calendar.add(Calendar.YEAR, -4);
        calendar.add(Calendar.MONTH, 5);

//      任意一年而又有多少天，三月一日的前一天就是
        int year=2012;
        calendar.set(year,3,1);
        calendar.add(Calendar.DAY_OF_MONTH, -1);

        showDate(calendar);
    }

    private static void showDate(Calendar calendar) {       
//      获取其中所需日期
        int year=calendar.get(Calendar.YEAR);
        int month=calendar.get(Calendar.MONTH);
        int day=calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));

        String week=getWeek(calendar.get(Calendar.DAY_OF_WEEK));
        System.out.println(week);

        System.out.println(year+"年"+month+"月"+day+"日"+week);
    }

    private static String getWeek(int i) {
        String[] week={"","星期一","星期二","星期三","星期四","星期五","星期六","星期天",};
        if(i>7 || i<=0){
            throw new NotWeekException("没有对应的星期1-7");//此异常必须继承RunableException
        }
        return week[i];
    }
}

package cn.myapi.demo;

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

public class CalendarDemo2 {
    /**
    * @param 演示日历  Calendar 2016.5.22-2017.2.19
    * 1、只有毫秒可以相减
    * 2、获取毫秒值，字符串-->日起对象-->毫秒值
     * @throws ParseException 
    */
    public static void main(String[] args) throws ParseException{
        getDays();
    }

    public static void getDays() throws ParseException {
        String string_date1="2016/5/22";
        String string_date2="2017/2/19";

//      如何将日期格式字符串解析成日期对象呢？
//      DateFormat parse
//      自定义yyyy/MM/dd风格对象
        DateFormat dateFormat1=new SimpleDateFormat("yyyy/MM/dd");

//      2、定义一个默认的风格
        DateFormat dateFormat2=DateFormat.getDateInstance(DateFormat.MEDIUM);
        /*Date date=new Date();
        String str_date=dateFormat1.format(date);
        System.out.println(str_date);*/

//      对日期格式字符串进行解析
        Date date1=dateFormat1.parse(string_date1); 
        Date date2=dateFormat1.parse(string_date2);

//      通过日期对象获取毫秒值
        long time1=date1.getTime();
        long time2=date2.getTime();

//      相减
        long time=Math.abs(time1-time2);
        System.out.println(time);
        int day=transDay(time);
        System.out.println(date1);
        System.out.println(date2);
        System.out.println(day);
    }


    private static int transDay(long time) {

        return (int)(time/1000/60/60/24);
    }
}

Collection

package cn.myapi.demo;

public class CollectionDemo {
    /**
    * @param 模拟一个 Collections min(Collecton coll,Comparator comp)
    */
    public static void main(String[] args) {
        String[] arr=new String[3];
        swap(arr,1,2);
    }

    /**
     * @param arr
     * @param i
     * @param j
     */
    public static <T> void swap(T[] arr, int i, int j) {
        T temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

package cn.myapi.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
public class CollectionDemo1 {
    /**
    * @param 集合框架的工具类
    * Collections:定义的都是操作Collections的静态方法
    * 1、对list排序
    *   sort(list);
    * 
    * public static<T extends Comparable<? super T>> void sort(List<T> list) {//泛型方法

    }

    class Student implements Comparable<Student>{
        public static void sort(List<Student> list) {

        }
        @Override
        public int compareTo(Student o) {
            return 0;
        }
    }

    2、逆序：reverseOrder
    3、max min
    4、二分查找
    5、将非同步集合转成同步集合


    Arrays：用来操作数组的操作类
    */
    public static void main(String[] args) {
        methodDemo1();
    }

    /**
     * 
     */
    private static void methodDemo1() {
        List<String> list=new ArrayList<String>();
        list.add("absdc");
        list.add("12x3");
        list.add("adefdc");

//      对List排序，自然排序。使用的是元素的compareTo()
        Collections.sort(list);

//      按长度排序
//      Collections.sort(list,new ComparatorByLength());//长度排序

        Collections.sort(list,Collections.reverseOrder(new ComparatorByLength()));//reverseOrder强行逆转比较器的功能
        System.out.println(list);


        System.out.println("----------------------------");
        Collection<String> collection=new ArrayList<String>();
        collection.add("fffff");
        collection.add("ggggg");
        collection.add("tttt");
        String max=getMax(collection);
        System.out.println(max);

        String max1=Collections.max(collection,new ComparatorByLength());
        System.out.println(max1+"\t"+"max1");

    /*  
        Collections中有一个可以将非同步集合转为同步集合的方法
        同步synchronize集合(非同步集合);
    */  
    }

//  模拟一个获取集合最大值的功能
    public static<T extends Object &Comparable<? super T>> T getMax(Collection<? extends T> collection) {
        Iterator<? extends T> iterator=collection.iterator();
        T max=iterator.next();
        while(iterator.hasNext()){
            T temp=iterator.next();
            if(temp.compareTo(max)>0){
                max=temp;
            }
        }
        return max;
    }
    /*
    public static String getMax(Collection<String> collection) {
//      1、定义变量记录容器中其中一个
//      2、遍历容器所有的元素
//      3、在遍历过程中进行比较。只要比变量的中的值大。用变量记录下来，就行
        Iterator<String> iterator=collection.iterator();
        String max=iterator.next();
        while(iterator.hasNext()){
            String temp=iterator.next();
            if(temp.compareTo(max)>0){
                max=temp;
            }
        }
        return max;
    }
    */

}

CollectionToArray

package cn.myapi.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class CollectionToArray {
    /**
    * @param args
    */
    public static void main(String[] args) {
//      集合转成数组
        List<String> list=new ArrayList<String>();
        list.add("abc");
        list.add("123");
/*      
        传入的数组长度，如果小于集合长度，方法中会创建一个新的长度和集合长度一致的数组
        如果传入的数组长度大于集合的长度，会使用传入的数组，所以建议长度定义为集合的size()

        为什么要把集合转成数组？就是为了限定对元素的操作，比如增删
*/      
//      String[] arr=list.toArray(new String[3]);
        //改成如下
        String[] arr=list.toArray(new String[list.size()]);
        System.out.println(Arrays.toString(arr));
    }
}

ComparatorByLength

package cn.myapi.demo;

import java.util.Comparator;

public class ComparatorByLength implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {
        int temp=o1.length()-o2.length();
        return temp==0?o1.compareTo(o2):temp;
    }
    /**
    * @param args
    */
}

Date

package cn.myapi.demo;

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

public class DateDemo {
    /**
    * @param args
    */
    public static void main(String[] args)throws ParseException {
//      演示Date对象
        Date date=new Date();
//      System.out.println(date);

//      想要把日期按照我们的习惯格式化一下，找到了DateFormat
        DateFormat dateFormat =DateFormat.getDateInstance();

//      加入风格
        dateFormat=DateFormat.getDateInstance(DateFormat.FULL);// 由 2017-3-22 转为  2017年3月22日 星期三
        dateFormat=DateFormat.getDateInstance(DateFormat.LONG);// 由 2017-3-22 转为  2017年3月22日
        dateFormat=DateFormat.getDateInstance(DateFormat.MEDIUM);// 由 2017-3-22 转为 2017-3-22
        dateFormat=DateFormat.getDateInstance(DateFormat.SHORT);// 由 2017-3-22 转为 17-3-22       
        dateFormat=DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL);// 由 2017-3-22 转为 2017年3月22日 星期三 上午11时45分41秒 CST

//      使用DateFormat的format方法对日期进行格式化,将日期对象转成日期格式的字符串
        String string=dateFormat.format(date);

//      System.out.println(string);

//      日期格式的字符串：2017-03-33
        String str_date="2017-03-22";
        DateFormat dateFormat2=DateFormat.getDateInstance();
        Date date2=dateFormat2.parse(str_date);
        System.out.println(date2);

        long time=System.currentTimeMillis();
        System.out.println(time);//1490155236256

        Date date3=new Date(time);
        System.out.println(date3);

        DateFormat dateFormat3=DateFormat.getDateInstance(DateFormat.LONG);
        System.out.println(dateFormat3);

        String date_format=dateFormat3.format(date3);
        System.out.println(date_format);

//      日期对象转成毫秒值，Date的对象getTime()
        long time3=date.getTime();
        System.out.println(time3);

    }
}

NotWeekException

package cn.myapi.demo;

public class NotWeekException extends RuntimeException {

    /**
     * 
     */
    public NotWeekException() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
     * @param arg0
     * @param arg1
     * @param arg2
     * @param arg3
     */
    public NotWeekException(String arg0, Throwable arg1, boolean arg2, boolean arg3) {
        super(arg0, arg1, arg2, arg3);
        // TODO Auto-generated constructor stub
    }

    /**
     * @param arg0
     * @param arg1
     */
    public NotWeekException(String arg0, Throwable arg1) {
        super(arg0, arg1);
        // TODO Auto-generated constructor stub
    }

    /**
     * @param arg0
     */
    public NotWeekException(String arg0) {
        super(arg0);
        // TODO Auto-generated constructor stub
    }

    /**
     * @param arg0
     */
    public NotWeekException(Throwable arg0) {
        super(arg0);
        // TODO Auto-generated constructor stub
    }
    /**
    * @param args
    */

}

RuntimeDemo

package cn.myapi.demo;

import java.util.Random;

public class RuntimeDemo {
    public static void main(String[] args) throws Exception{
//      单例模式对象Runtime
        Runtime runtime=Runtime.getRuntime();
//      runtime.exec("notepad.exe");
//      Math 数学类，都是静态成员
        double d1=Math.ceil(12.43);
        double d2=Math.floor(12.43);
        double d3=Math.round(12.43);
/*      
        System.out.println("d1="+d1);
        System.out.println("d2="+d2);
        System.out.println("d3="+d3);
        System.out.println(Math.pow(10, 3));
    */  
        for (int i = 0; i < 10; i++) {
            double d=Math.ceil(Math.random()*10);
            System.out.println(d);
        }

        Random random= new Random();
        for (int i = 0; i < 10; i++) {
            int d=random.nextInt(6)+1;
            System.out.println("random"+d);
        }
    }
}

staticImport

package cn.myapi.demo;

import java.util.ArrayList;
import java.util.List;
import static java.util.Collections.*;
import java.util.*;
import static java.lang.System.*;

public class StaticImportDemo {

    public static void main(String[] args) {
    /*  
        List list=new ArrayList();
        Collections.sort(list);
        Collections.max(list);
        System.out.println(Collections.max(list));
    */
        List<String> list=new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("123");
        sort(list);

        System.out.println(max(list));
        out.println("Hello");
    }

    /**
     * @param list
     * @return
     *//*
    private static char[] max(List<String> list) {
        return null;
    }

    *//**
     * @param list
     *//*
    private static void sort(List<String> list) {
    }*/
}

SystemDemo

package cn.myapi.demo;

import java.util.Properties;
import java.util.Set;

public class SysteDemo {
    private static final String FILE_SEPARATOR=System.getProperty("file.separator");
    private static final String LINE_SEPARATOR=System.getProperty("line.separator");
    public static void main(String[] args) {
    /*  
        System:全是静态的行为和属性
        属性：
        out：标准输出流，默认对应设备显示器
        in：标准输入流，默认的设备键盘
    */  
        long time= System.currentTimeMillis();
//      System.out.println(time);

//      System getProperties(); 获取到系统的信息都存储到Properties键值集合中了
        Properties properties =System.getProperties();

//      如何去除属性集？
        Set<String> set =properties.stringPropertyNames();

        for(String key :set){
            String value=properties.getProperty(key);
//          System.out.println(key+":"+value);
        }
//      System.out.println(System.getProperty("os.name")+"ssssssssssssssssss");

        System.out.println("C:"+FILE_SEPARATOR+"abc"+FILE_SEPARATOR+"1.txt");//会变成文件路径
        System.out.println("hello "+LINE_SEPARATOR+"world!");//会分割换行
    }
}