Java API

java.util

java.util被称为java工具包，里面包含大部分的工具，包括：

java.util.ArrayList

package api;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
/** 
 * 
 * 尚未学会的方法：
 * 1.sort(Comparator<? super E> c)
	使用提供的 Comparator对此列表进行排序以比较元素。
	2.replaceAll(UnaryOperator<E> operator)
	将该列表的每个元素替换为将该运算符应用于该元素的结果。
 * 3.removeRange(int fromIndex, int toIndex)
	从这个列表中删除所有索引在 fromIndex （含）和 toIndex之间的元素。
	4.spliterator()
 	在此列表中的元素上创建late-binding和故障快速 Spliterator 。
 	5.toArray(T[] a)
	以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。
 */
public class ArrayList1 {
		
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		// 新建两个列表
		ArrayList<String> list1 = new ArrayList<String>();
		ArrayList<String> list2 = new ArrayList<String>(10);
		ArrayList<String> list3 = new ArrayList<String>();
		
		// 如果需要，增加此 ArrayList实例的容量，以确保它可以至少保存(参数)指定的元素数。
		list1.ensureCapacity(40);
		System.out.println(list1.size());
		
		// 将String类型的元素添加到列表的末尾,返回值为boolean;
		list1.add("zero");
		list2.add("one");
		
		// 在列表的指定位置插入指定元素
		list1.add("two");
		
		// 在列表末尾插入另外一个列表的所有元素
		list1.addAll(list2);
		list1.add(1,"three");
		
		// list1 到 list3 的浅拷贝（即只拷贝引用),原来列表改变会改变新表
		list3 = (ArrayList<String>) list1.clone();
		
		
		// 检验改变复制后的列表是否会改变原列表（不会)
		list3.remove(1);
		list3.add("four");
		
		// 检测改变原列表是否会改变复制后的列表(克隆之后改变原列表没有改变clonedlist)
		list1.add("five");
		
		// 从列表的指定位置插入另一个列表的所有元素
		list1.addAll(3,list2);
		list1.addAll(list3);
		
		// 清除列表中的所有元素
		// list2.clear();
		
		// 删除指定位置的元素 该方法返回删除的元素
		// list2.remove(0);
		// System.out.println("remove?" + list2.remove(0));
		
		// 删除列表中指定元素的第一个出现
		// list1.remove("one");
		
		// 删除列表与列表交集的元素
		// list1.removeAll(list3);
		
		// 删除从fromIndex 到 toIndex 中的元素 revoveRange() 不可视
		// list1.removeRange(3,5);
		
		// 将该列表的每个元素替换为将该运算符应用于该元素的结果
		// failed;
		
		// 仅保留此列表中包含在指定集合中的元素。
		list1.retainAll(list3);
		
		// 用指定的元素替换此列表中指定位置的元素。
		list1.set(0, "one");
		
		// 返回列表中的元素数
		int length = list1.size();
		
		
		// 判断列表中是否含有指定元素
		boolean m = list1.contains("zero");
		System.out.println("list1 contains ？ " + m);
		
		// 判断列表中是否含有另外列表中的所有元素
		boolean n = list1.containsAll(list3);
		System.out.println("list1 contans ?" + n);
		
		// 返回指定位置的元素
		System.out.println(list1.get(1));	
		
		// 返回该元素在列表中的位置(如果有多重位置只返回第一个)
		System.out.println("indexOf :" + list1.indexOf("one"));
		
		// 判断该表是否为空
		System.out.println("isEmpty:" + list2.isEmpty());
		
		// 返回此列表中指定的 fromIndex （包括）和 toIndex之间的元素（包含from 不包含 end)
		System.out.println("sublist:" + list1.subList(2, 4));
		
		//Iterator迭代器的使用
		Iterator<String> ite = list1.iterator();
		String str="";
		while(ite.hasNext()) {
			str += ite.next();
		}
		System.out.println("iterator: " + str);
		
		// 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
		System.out.println("lastIndexOf :" + list1.lastIndexOf("one"));
		
		// 由此延伸出一种判断列表中某元素是否只出现一次的方法：即判断indexOf()和lastIndexOf()是否相等；
		boolean k = true;
		if(list1.indexOf("one") != list1.lastIndexOf("one")) {
			k = false;
		}
		System.out.println("once?" + k);
		
		// 从列表中的指定位置开始，返回列表中的元素（从指定位置）的列表迭代器。
		ListIterator<String> ite2 = list1.listIterator(5);
		String str2 = " ";
		while(ite2.hasNext()) {
			str2 += ite2.next();
		}
		System.out.println("str2: " + str2);
		
		// 新建数组
		String [] a = new String[list1.size()];
		
		// 将列表中的元素返回到自建的数组中
		list1.toArray(a);
		String [] b = new String[list2.size()];
		list2.toArray(b);
		
		 // 修改这个 ArrayList实例的容量是列表的当前大小。
		list1.trimToSize();
		list2.trimToSize();
		list3.trimToSize();
		System.out.println("size of list1: " + list1.size() + "size of list2: " + list2.size() + "size of list3: " + list3.size());
		
		// 直接输出列表
		System.out.println("list1:" + list1);
		System.out.println("list2:" + list2);
		System.out.println("list3:" + list3);
	
		// 依次输出列表中的元素
		System.out.println("list1:");
		
		// for EACH
		for(String s:a) {
			System.out.println(s);
		}
		System.out.println();
		System.out.println("list2:");
		for(String f: b) {
			System.out.println(f);
		}
	}
}

java.util.Random

Random类作为java中用于产生随机数的类，如new Random(10),10是种子数。

注意：Random的一个特点是：相同种子数的Random对象，对应相同次数产生的随机数是完全相同的。

1）Random生成随机数

Random random = new Random();
for(int i = 0; i<=4; i++ ) {
	// nextInt(10)的意思是返回大于等于0，小于10的一个正整数，要想生成多少位的随机数，只需修改参数值即可；
    System.out.println(random.nexInt(10));
}

2）math.random()生成的是一个伪随机数，何为伪随机数，这里java是以当前系统时间的相关数字作为种子数，按照特定复杂算法生成的，其实它生成的大量随机数是线性均匀分布的，黑客是完全可能通过返回的大量随机数结果破解种子数的，所以它并不是真正的随机，叫伪随机数。由此我们可以知道通过计算机生成一个真随机数几乎是不可能的，因为最终的输出结果都是依赖算法程序的，这些算法程序本身就是固定的，我们只能通过更复杂的算法不断优化，让它无限趋近于真随机数，但不绝对。
案例：

// 生成一个5位数的随机数，想生成几位就*n
for(int i = 0; i < 100; i++) {
	System.out.println((int)((Math.random()*9+1)*n));
}

java.util.Date

Date类的基本用法：

import java.text.SimpleDateFormat;
// concurrent 同时发生的并存的  modification 修改 更改.n
import java.util.ConcurrentModificationException;
import java.util.Date;
public class Test2 {
    public static void main(String[] args) throws Exception {
		Date date = new Date();
        // 返回当前的时间
        System.out.println(date);
        // SimpleDateFormate 主要用来对日期进行格式转换
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String time = "2022-05-17";
        // 把String类型转换成date类型
        Date date1 = (Date)simpleDateFormat.parse(time);
        System.out.println(date1);
        // 把date类型转换成String类型
        String dateStr = simpleDateFormat.format(date1);
        System.out.println(dateStr);
    }
}

java.util.Calendar

Calendar c = Calendar.getInstance();
/**
关于getInstance();

public class Singleton{
    private Singleton(){}    //private 只能在自己内部供自己去访问
    private static Singleton instance=new Singleton();//在自己内部定义自己的一个实例
    public static Singleton getInstance(){         //此静态方法供外部直接访问
return instance;
    }
}
判断Singelton一个类是否是单例模式：

class Test{
    public static void main(String args[]){
Singleton s1=Singleton.getInstance();
Singleton s2=Singleton.getInstance();
if(s1==s2)
System.out.println("此类是单例模式");
else
System.out.println("此类不是单例模式");
    }
}
*/
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);
int day = c.get(Calendar.DAY_OF_MONTH);
int hour = c.get(Calendar.HOUR_OF_DAY);
int min = c.get(Calendar.MINUTE);
int sec = c.get(Calendar.SECOND);
int w = c.get(Calendar.DAY_OF_WEEK);
/**
Calendar 是一个抽象类，需要通过getInstance()方法来实现；
Calendar 和 Date 之间的转换分别是getTime()和setTime();
Calendar 获取的月份从0开始计数；
Calendar对象获取day_of_week是获取到当前星期，返回的是从这周日到当前礼拜的天数。
**/
import javax.xml.crypto.Data;
import java.util.Date;
import java.util.Calendar;
import java.util.Random;

public calss Test1 {
    
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        Date date = new Date();
        // 把date set 到calendar;
        calendar.setTime(date);
        // 获取当前的年份
        System.out.println(calendar.get(Calendar.YEAR));
        // 当前年+1
        calendar.add(Calendar.YEAR,1);
        System.out.println(calendar.get(Calendar.YEAR));
    }
}

jdk1.8的时间：

一、jdk8与之前的日期和时间处理类的不同：

Java的java.util.Date和java.util.Calendar类易用性差，不支持时区，并且是可变的，也就意味着他们都不是线程安全的；
用于格式化日期的类DateFormat被放在java.text包中，它是一个抽象类，所以我们需要实例化一个SimpleDateFormat对象来处理日期格式化，并且DateFormat也是非线程安全，这意味着如果你在多线程程序中调用同一个DateFormat对象，会得到意想不到的结果。
对日期的计算方式繁琐，而且容易出错，因为月份是从0开始的，这意味着从Calendar中获取的月份需要加一才能表示当前月份
由于以上这些问题，出现了一些三方的日期处理框架，例如Joda-Time，data4j等开源项目
二、Java 8日期/时间类
Java 8的日期和时间类包含LocalDate、LocalTime、Instant、Duration以及Period，这些类都包含在java.time包中。

java.lang

java.lang.String

java.swing

Swing 是一个为Java设计的GUI工具包。Swing是JAVA基础类的一部分。Swing包括了图形用户界面（GUI）器件如：文本框，按钮，分隔窗格和表。Swing提供许多比AWT更好的屏幕显示元素。它们用纯Java写成，所以同Java本身一样可以跨平台运行，这一点不像AWT。它们是JFC的一部分。它们支持可更换的面板和主题（各种操作系统默认的特有主题），然而不是真的使用原生平台提供的设备，而是仅仅在表面上模仿它们。这意味着你可以在任意平台上使用JAVA支持的任意面板。轻量级组件的缺点则是执行速度较慢，优点就是可以在所有平台上采用统一的行为。

javax.swing.JPanel(面板)

JPanel,面板。是在开发中使用频率非常高的一般轻量级面板容器组件。

JPanel常用的构造方法

// 创建默认使用流式布局的面板
JPanel()
// 创建指定布局管理器的面板
JPanel(LayoutManager layout)

代码实例

package com.xiets.swing;

import javax.swing.*;
import java.awt.*;

public class Main {

    public static void main(String[] args) {
        JFrame jf = new JFrame("用户登录");
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // 第 1 个 JPanel, 使用默认的浮动布局
        JPanel panel01 = new JPanel();
        panel01.add(new JLabel("用户名"));
        panel01.add(new JTextField(10));

        // 第 2 个 JPanel, 使用默认的浮动布局
        JPanel panel02 = new JPanel();
        panel02.add(new JLabel("密   码"));
        panel02.add(new JPasswordField(10));

        // 第 3 个 JPanel, 使用浮动布局, 并且容器内组件居中显示
        JPanel panel03 = new JPanel(new FlowLayout(FlowLayout.CENTER));
        panel03.add(new JButton("登录"));
        panel03.add(new JButton("注册"));

        // 创建一个垂直盒子容器, 把上面 3 个 JPanel 串起来作为内容面板添加到窗口
        Box vBox = Box.createVerticalBox();
        vBox.add(panel01);
        vBox.add(panel02);
        vBox.add(panel03);

        jf.setContentPane(vBox);

        jf.pack();
        jf.setLocationRelativeTo(null);
        jf.setVisible(true);
    }

}