Java学习总结（ 一 ）
Arrays类（java.util.Arrays)及常用方法：
1）针对数组操作的工具类。此类包含用来操作数组的各种方法，所有方法都是静态方法，比如排序和搜索（主要为binarysearch二分搜索）。需要注意的是如果指定数组引用为null，则此类的方法都会抛出异常NullPointerException。
2）常用方法：
（1）public static void sort（int[] a） 这里用int类型数组举例，作用是将数组a中的元素按升序进行排序，而排序算法是经过调优的快速排序，数组可 以是 byte类型，char类型double类型等等，还可以是对象数组（对象数组就是存储对象的数组）。
（2）public static String toString (int[] a) 同样的用int类型数组来举例（同样的参数可以是多种类型，包括对象数组）返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成，括在方括号（"[]"）中。相邻元素用字符 ", "（逗号加空格）分隔。这些元素通过 String.valueOf(int)转换为字符串。如果 a 为 null，则返回 "null"。底层代码如下：
public static String toString(int[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}sort(int[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。不过多赘述。源码如下
public static int binarySearch(int[] a, int key) {
return binarySearch0(a, 0, a.length, key);
} private static int binarySearch0(int[] a, int fromIndex, int toIndex,
int key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}Calendar类（Java.util.Calendar)
1)抽象类,为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法。可以用其方法getInstance来获得一个Calendar对象
2)其中的字段例如YEAR都是静态的，因此需要通过其静态方法访问 对象名.get(Calendar.TEAR) 相同的有set来设置日期 比如 对象名.set(2018.2.2)
3)对象名.add(Calendar.YEAR，-3）add方法可以用来对其字段进行+-设置。
System类（java.lang.System）
包含一些有用的类字段和方法。它不能被实例化
public static void gc()
public static void exit()
public static long currentTimeMillis()
public static void arraycopy(object src,int srcPos,object dest, int destPos,int length) 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束
src:原数组
dest:目标数组
srcPos :从原数组的哪个位置开始
destPos:到目标数组的哪个位置结束
length:长度
1) System.gc() 运行垃圾回收器，回收空对象
2）System.exit() 参数为0，终止JVM
3) System.currentTimeMillis() 返回以毫秒为单位的当前时间，一般用来测试代码执行效率
Date类（java.util.Date）
1) 构造方法：public Date()表示分配它的时间（精确到毫秒）
public Date(long date):创建一个日期对象,指定毫秒值
public void setTime(long time):设置毫秒值
2)常用方法
public long getTime() 将Date--->long的毫秒值（类似System.currentTimeMillis()）
重点：Date---->String(格式化) String-->Date(解析） 中间转换中间的转换:使用中一个中间 类:DateFormat,并且DateFormat是一个抽象类,抽象意味着不能实例化,所以应该考虑用它的子类:
SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。
SimpelDateFormat的构造方法:
public SimpleDateFormat(String pattern) :构造一个SimpleDateFormat对象,根据pattern(模式:规则）
SimpleDateFormat sdf = new SimpleDateFormat("xxx年xx月xx日") ;
年: yyyy
月: MM
日: dd
时: hh
分: mm
秒: ss
public static void main(String[] args) throws ParseException {
//Date---String:(格式化)
//创建一个日期对象
Date d = new Date() ;
//创建SimpleDateFormat类对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//public final String format(Date date):格式化
String str = sdf.format(d) ;
System.out.println("str:"+str);
System.out.println("----------------------");
//String:日期文本格式:---->Date:日期格式
// public Date parse(String source):解析
String strDate = "2018-6-25" ;
//创建SimpleDateFormat类对象
// SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日") ;
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd") ;
// 注意 :simpleDateFormat在解析文本格式的时候,里面 模式(规则)一定要和文本格式的模式一直,否则就出现PareseException
Date d1 = sdf1.parse(strDate) ;
System.out.println("d1:"+d1);
}public class DateUtil {
//无参构造私有化
private DateUtil() {
}
/**
* 将Date转为String
*/
public static String dateToString(String format,Date d) {
/*SimpleDateFormat sdf = new SimpleDateFormat(format) ;
String s = sdf.format(d) ;
return s ;*/
return new SimpleDateFormat(format).format(d) ; //链式编程
}
/**
* 将String转为Date
* @throws ParseException 解析如果出问题了,就会有这个异常
*/
public static Date stringToDate(String format,String s) throws ParseException {
return new SimpleDateFormat(format).parse(s) ; //链式编程
}
}
Math类
提供了一些数学方法：
public static int abs(int a):绝对值
public static double ceil(double a):向上取整
public static double floor(double a):向下取整
public static int max(int a,int b):求最大值
public static int min(int a,int b):求最小值
public static double pow(double a,double b):a的b次幂
public static double random()返回带正号的 double 值，该值大于等于 0.0 且小于 1.0
public static int round(float a):四射五入
public static double sqrt(double a):一个数的正平方根
Random类（java.util.Random）
public Random(long seed) :指定long类型的数据进行构造随机数类对象
public int nextInt():获取随机数,它的范围是在int类型范围之内
public int nextInt(int n):获取随机数,它的范围是在[0,n)之间
Matcher和Pattern类（java.util.regex.）
public static boolean matches(String regex, CharSequence input) 编译给定正则表达式并尝试将给定输入与其匹配。
CharSequence为接口，已知的实现类：
-
CharBuffer, Segment, String, StringBuffer, StringBuilder
-
Pattern类中提供正则表达式相关字符及其含义：
x x字符
\\ 反斜线字符
\t 制表符
\n 换行符
\r 回车符
| . | 任何字符（与行结束符可能匹配也可能不匹配） |
| \d | 数字：[0-9] |
| \D | 非数字： [^0-9] |
| \s | 空白字符：[ \t\n\x0B\f\r] |
| \S | 非空白字符：[^\s] |
| \w | 单词字符：[a-zA-Z_0-9] |
| \W | 非单词字符：[^\w] |
| X? | X，一次或一次也没有 |
| X* | X，零次或多次 |
| X+ | X，一次或多次 |
| X{n} | X，恰好 n 次 |
| X{n,} | X，至少 n 次 |
| X{n,m} | X，至少 n 次，但是不超过 m 次 |
主要记住上面的就行
实例：
public class RegexTest {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc =new Scanner(System.in) ;
//接收数据
System.out.println("请输入一个邮箱:");
String email = sc.nextLine() ;
//定义正则规则
// String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z_0-9]+){1,4}" ;
String regex = "\\w+@\\w{2,6}(\\.\\w+){1,4}";
boolean flag = email.matches(regex) ;
System.out.println("flag:"+flag);
}
}String 类中提供了一个分割功能方法 split（）以及replaceAll () 都会用到正则表达式
public String replaceAll (String regex,String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
用法：
String s = "hello12345World781323244454JavaEE" ;
//需求:要将数字字符被替换成*
String regex = "\\d+" ;
//定义替换的字符串
String ss = "*" ;
String result = s.replaceAll(regex, ss) ;public String[] split(String regex)
根据给定正则表达式的匹配拆分此字符串。返回的是字符串数组。
用法：
String s1 = "aa,bb,cc" ;
String[] str = s1.split(",") ;
for (int x = 0; x < str.length; x++) {
System.out.println(str[x]);接口 Collection
集合，数组 ,字符串缓冲区(StringBuffer)都是容器，各自有各自的作用。
数组：存储单一数据类型
字符串缓冲区(StringBuffer)：存储字符串
集合可以存储多种类型的数据（只能是引用类型）
数组和集合的区别?
* 1)长度区别:
* 数组长度固定
* 集合长度可变
* 2)内容的区别
* 数组可以存储同一种类型的元素
* 集合可以存储多种类型的元素
* 3)存储类型的区别
* 数组:可以存储基本类型,也可以存储引用类型
* 集合:只能存储引用类型
集合继承体系图（网上下载的）：
我们暂时并未提到 Queue类
* 数据结构:数据的存储方式
*
* Collection:
* Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。
* JDK 不提供此接口的任何直接 实现：它提供更具体的子接口,更具体的实现类
*基本功能:
*添加功能:
* boolean add(Object e) 只要添加就返回true
*删除功能:
* void clear() : 删除集合中所有元素(暴力删除)
* boolean remove(Object o):删除集合中的指定元素
*判断功能:
* boolean contains(Object o):集合中是否包含指定的元素
*获取功能:
* int size() :获取集合中的元素数
* boolean retainAll(Collection c) :交集功能: A集合对B集合取交集,交集的元素要去A集合中,boolean返回值表达的A集合的元素是否发生变化,如果发生变化,则返回true,否则,返回false
* boolean removeAll(Collection c):删除一个集合中所有元素，删除一个元素就算是删除
* boolean containsAll(Collection c):集合中是否包含指定的集合的所有元素，包含所有才算是包含
*转换功能:
* Object[] toArray() :将集合转换成数组
toArray（）方法测试
Collection c = new ArrayList() ;
//给集合中添加元素
c.add("hello") ;
c.add("world") ;
c.add("java") ;
//需要去转换
// Object[] toArray()
//将集合转成数组
Object[] objs = c.toArray() ;
for(int x =0 ; x < objs.length ; x ++) {
String str = (String) objs[x] ; //相当于:向下转型
System.out.println(str+"----"+str.length());
}注意：过程中要注意对象的转换，开始集合中存储的对象类型应该与向下转型时的对象类型一致
接下来说说集合所特有的东西，那就是迭代器遍历
接口 Iterator
*Iterator iterator() :集合的迭代器方法(获取集合的迭代器)
* Iterator :接口中有以下的方法:
* boolean hasNext() :如果有元素可以迭代,那么返回true,否则返回false
* Object next()返回迭代的下一个元素。
* 以存储String类型的元素举例
运用如下：
//创建集合对象
Collection c = new ArrayList() ;
//添加元素
c.add("hello");
c.add("world");
c.add("java");
//通过集合获取迭代器
Iterator it = c.iterator() ;此时与其提供的方法结合：
while(it.hasNext()) {
Object obj = it.next() ; //Object obj = new Object(); 创建对象接收迭代返回的对象
//需求:打印字符串同时,获取长度
String str = (String) obj ;
String str = (String)(it.next()) ;
System.out.println(str+"---"+str.length());
}* 1)it.next(),只使用一次即可,使用多次,会出现问题(it.next(),每次使用的时候都是返回一个对象)
* 2)遍历的时候使用的while循环,可不可以使用for循环呢?
相同的我们用存储String类型对象的集合举例：
Collection c = new ArrayList() ;
//添加元素
c.add("hello");
c.add("world");
c.add("java"); for(Iterator it = c.iterator() ; it.hasNext();) {
String str =(String)it.next() ;
System.out.println(str+"---"+str.length());
}for循环在此处并不常见，应对其源码有所了解
* Collection有两个子接口:List Set
*List集合的特点:
* 有序的 (存储和取出一致),可以允许重复元素
*
*Set集合的特点:
* 无序性(不能保证迭代的顺序,基于hashMap),并且元素不能重复
创建集合对象
List list = new ArrayList() ;迭代器运用
Iterator it = list.iterator() ;* 添加功能
* void add(int index,Object element):在指定位置处添加指定元素
* 获取功能
* Object get(int index)返回列表中指定位置的元素。
* ListIterator listIterator():列表迭代器
* 删除功能:
* Object remove(int index):删除指定位置处的元素
* 修改功能
* Object set(int index, Object element):用指定element元素替换掉指定位置处的元素
ListIterator listIterator():列表迭代器 (List集合的专有迭代遍历:列表迭代器)
*ListIterator接口中:
* boolean hasNext() :判断是否有下一个可以迭代的元素(正向遍历)
* Object next():获取下一个元素
* boolean hasPrevious():判断是否有上一个可以迭代 元素(逆向遍历)
* Object previous():返回上一个元素
*
*逆向迭代(遍历),单独使用没意义,前提,要先正向遍历
List list = new ArrayList() ;
list.add("hello") ;
list.add("world") ;
list.add("java") ;
//ListIterator listIterator():列表迭代器
ListIterator it = list.listIterator() ;
//正向遍历
while(it.hasNext()) {
String s = (String)it.next() ;
System.out.println(s+"---"+s.length());
}
System.out.println("--------------------------");
//boolean hasPrevious():判断是否有上一个可以迭代 元素(逆向遍历)
//Object previous():返回上一个元素
while(it.hasPrevious()) {
String s = (String)it.previous() ;
System.out.println(s+"---"+s.length());
}注意：如果我们用迭代器遍历List或者collection等，要添加或删除一个集合元素也必须使用迭代器来添加或删除，注意前后一致!
List集合有三个子实现类:
ArrayList
底层数据结构式数组结构,查询块,增删慢
从内存角度考虑:线程不安全的,不同步的,执行效率高
多线程:synchronized :同步的意思 解决线程安全问题
sychronized(锁对象){ 同步代码
共享数据;
}
解决线程安全问题,通过同步可以解决,但是效率低了...
LinkedList
:底层数据结构式链表结构,查询慢,增删块
从内存角度考虑:线程不安全,不同步,执行效率高
Vector:
这是一个线程安全的类,
底层数据结构是数组:查询快,增删慢
线程安全的,同步,执行效率低!
本次总结小结：
重点：
1)Date---->String(格式化) String-->Date(解析）注意使用中间抽象类DateFormat 的子类SimpleDateFormat以及 其方法parse（解析）和format（格式化），parse方法调用时注意格式串与String类型对象格式一致，注意抛出异常。
- 2)集合的创建，迭代器的获取，以及集合的遍历
【开源 （03-24）java开发】
【2018.5.2】