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(", ");
}
}
(3)public static int binarySearch(int[] a, int key) 使用二分搜索法来搜索指定的 int 型数组,以获得指定的值。必须在进行此调用之前对数组进行排序(通过
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.
}
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方法可以用来对其字段进行+-设置。
包含一些有用的类字段和方法。它不能被实例化
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() 返回以毫秒为单位的当前时间,一般用来测试代码执行效率
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) ; //链式编程
}
}
提供了一些数学方法:
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):一个数的正平方根
public Random(long seed) :指定long类型的数据进行构造随机数类对象
public int nextInt():获取随机数,它的范围是在int类型范围之内
public int nextInt(int n):获取随机数,它的范围是在[0,n)之间
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]);
集合,数组 ,字符串缓冲区(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());
}
注意:过程中要注意对象的转换,开始集合中存储的对象类型应该与向下转型时的对象类型一致
接下来说说集合所特有的东西,那就是迭代器遍历
运用如下:
//创建集合对象
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());
}
* 注意:
* 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() ;
*List集合的特有功能:
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类型对象格式一致,注意抛出异常。
【开源 (03-24)java开发】
【2018.5.2】