1.Arrays:
针对数组操作的工具类 (提供了一些针对数组排序和二分搜索法)
方法：
* public static StringtoString(int[] a):可以将int类型的数组转换成字符串 (以[元素1,元素2,元素3...]形式输出)
* public static void sort(int[] a)对指定的 int 型数组按数字升序进行排序（快排法）
* public static int binarySearch(int[] a,intkey):二分搜索法: 在int类型的数组中查找key元素的索引（用此方法前先排序再查找）
直接调用如Arrays.toString(arr)
Arrays.sort(arr)
-------------------------------------------------------------------------------------------------------------------------------------------------------
toString(int[] a)的源码
以后在实际开发中,只要有引用类型,在对引用类型数据进行操作的时候,对引用类型的对象进行非空判断,
防止空指针异常(NullPointerException)
//int[] arr = {24,69,80,57,13} ;
public static String toString(int[] a) {
if (a == null) //对数组进行非空判断
return "null";
int iMax = a.length - 1; //arr.length-1 //a--->arr
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(", "); //如果不是最后一个索引,那么中间追加逗号
}
}
-------------------------------------------------------------------------------------------------------------------------------------------------------
publicstatic int binarySearch(int[] a,int key)的源码:
public static int binarySearch(int[] a, intkey) {//a--->arr key-->577
return binarySearch0(a, 0, a.length,key);
}
/**
a--->arr:指定的int类型的数组
fromIndex:指定索引开始:0
toIndex:arr.length5
key:577
*/
int[]arr = {13,24,57,69,80} ;
private static int binarySearch0(int[] a,int fromIndex, int toIndex,
int key) {
int low = fromIndex; //最小索引
int high = toIndex - 1;// 最大索引 4
while (low <= high) { //如果最小索引小于=最大索引
int mid = (low + high) >>>1; >>> :无符号右移动(位运算符) //中间索引:mid = 2 ,3 ,4
位^:位异或
位&:位与
位|:位或
<<:左移动
有符合的数据表示法(原码,反码,补码)
计算机底层运算数据的时候:通过补码进行运算的
int midVal = a[mid]; // 查找中间索引对应的元素:arr[2]= 57 69 80
if (midVal < key) //判断:中间索引对应的元素 <key =577
low = mid + 1; //low = mid + 1; mid = (取到最大的mid的值) 4+1 = 5
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found. //没有找到 return -(low+1) = -6
}
-------------------------------------------------------------------------------------------------------------------------------------------------------
2.calendar类
* Calendar 类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法
* Calendar 类是一个抽象类，如何实例化？
public static Calendar getInstance() :通过一个静态功能来创建日历的对象
如：CalendarrightNow = Calendar.getInstance() ;
通过代码体现calendar类中字段的应用：
public classCalendarDemo {
public static void main(String[] args){
//创建日历类的对象
// CalendarrightNow = new Calendar() ; 不能实例化 （错误写法）
Calendar rightNow =Calendar.getInstance() ;
//publicint get(int field)返回给定日历字段的值
//获取年:publicstatic final int YEAR
int year = rightNow.get(Calendar.YEAR);
//获取年中的月份:public static final int MONTH
int month =rightNow.get(Calendar.MONTH) ;
//publicstatic final int DATE :获取月份的那一天
int date =rightNow.get(Calendar.DATE) ;
//注意：month为0~11，所以要写出（month+1）
System.out.println(year+"年"+(month+1)+"月"+date+"日"); //通过日历类获取当前系统时间
}
}
-------------------------------------------------------------------------------------------------------------------------------------------------------
3. System 类
System 类包含一些有用的类字段和方法。它不能被实例化。
常用的方法:
publicstatic void gc()运行垃圾回收器。
publicstatic void exit(int status)终止当前正在运行的 Java 虚拟机。参数用作状态码； 一般情况,需要终止 Jvm,那么参数0
publicstatic long currentTimeMillis()返回以毫秒为单位的当前时间
单独使用,没有意义，一般情况,来测试一段代码的执行效率
publicstatic void arraycopy(Object src,int srcPos, Object dest,int destPos, intlength)
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束
src:原数组
dest:目标数组
srcPos :从原数组的哪个位置开始
destPos:到目标数组的哪个位置结束
length:长度
*/
代码示例：
public classSystemDemo {
public static void main(String[] args){
//创建一个Person类的对象
Person p = new Person("高圆圆",27) ;
System.out.println(p);
//让p对象不指定堆内存了
p = null ;
System.gc(); //运行垃圾回收器,实质是执行的finalize()方法
}
}
public classPerson {
private String name ;
private int age ;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person[name=" + name + ", age=" + age + "]";
}
@Override
protected void finalize() throwsThrowable {
System.out.println("开始回收不用的对象了:"+this);
super.finalize();
}
-------------------------------------------------------------------------------------------------------------------------------------------------------
4.Date类
* 类 Date 表示特定的瞬间，精确到毫秒
* 构造方法:
publicDate()表示分配它的时间（精确到毫秒）。
publicDate(long date):创建一个日期对象,指定毫秒值 (需要将long 时间毫秒值转换成Date对象)
* 方法：
* public long getTime()将Date--->long的毫秒值
代码示例：
package Xk;
importjava.util.Date;
public class Datem {
public static void main(String[] args) {
Date d = new Date() ;
System.out.println(d); //Date类型的日期格式:Wed May 0216:20:14 CST 2018
//Date的文本格式: String :2018-5-2
Date dd = new Date(3000);
System.out.println(dd);//Thu Jan 01 08:00:03 CST 1970
long time=d.getTime();
System.out.println(time);//1525249533117
}
}
重点:Date的日期格式和日期的文本格式:String类型之间进行转换
* Date---->String(格式化)
* String-->Date(解析)
* 中间的转换:使用中一个中间类:DateFormat,并且DateFormat是一个抽象类,抽象意味着不能实例化,所以应该考虑用它的子类:
* SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。
SimpelDateFormat的构造方法:
* publicSimpleDateFormat(String pattern) :构造一个SimpleDateFormat对象,根据pattern(模式:规则)
示例
* SimpleDateFormatsdf = new SimpleDateFormat("xxxx年xx月xx日") ;
* public final String format(Date date):格式化
* public Date parse(String source):解析
日期和时间模式
* 年: yyyy
* 月: MM
* 日: dd
*
* 时: hh
* 分: mm
* 秒: ss
代码示例：
package Xk;
importjava.text.ParseException;
import java.text.SimpleDateFormat;
importjava.util.Date;
public class Dateswap {
public static void main(String[] args) throwsParseException {
//Date---String:(格式化)
//创建一个日期对象
Date d = new Date() ;
//创建SimpleDateFormat类对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//publicfinal 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类对象
// SimpleDateFormatsdf2 = new SimpleDateFormat("yyyy年MM月dd日") ;（错误）
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
/* 注意 :simpleDateFormat在解析文本格式的时候,里面模式(规则)一定要和文本格式的模式一直,否则就出现PareseException*/
Date dd = sdf2.parse(strDate) ;
System.out.println("dd:"+dd);
}
}
5. Math 类
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
常用的方法:
* public static int abs(int a):绝对值
* publicstatic double ceil(double a):向上取整
* publicstatic double floor(double a):向下取整
* public static int max(int a,int b):求最大值
* public static int min(int a,intb):求最小值
* public static double pow(double a,double b):a的b次幂
* public static double random()返回带正号的 double 值，该值大于等于 0.0 且小于 1.0
* publicstatic int round(float a):四射五入
* public static double sqrt(double a):一个数的正平方根
直接调用即可，如：
inta=Math.abs(-10);//a=10
面试题:有两个变量,让他们的值进行互换 (考官想问的是:你能否指定位^的特点)
int a = 10 ;
int b = 20 ;
实际开发中:中间变量的方式进行互换
位^的特点:一个数据被另一个数据位^两次,其值是它本身
/*System.out.println(a^b^b);
System.out.println(a^b^a);*/
System.out.println("a:"+a+",b:"+b);
//=号左边: a ,b,a
//=右边: a^b
a = a ^ b ;
b = a ^ b ;//b = a^b ^ b a=20,b=10
a = a ^ b ;
代码示例
package Xk;
public class yihuo {
public static void main(String[] args) {
inta = 10 ;
intb = 20 ;
System.out.println("a:"+a+",b:"+b);// a:10,b:20
//=号左边:a ,b,a
//=右边: a^b
a = a ^ b ;
b = a ^ b ;//b = a^b ^ b
a = a ^ b;
System.out.println("a:"+a+",b:"+b); a:20,b:10
}
}
-------------------------------------------------------------------------------------------------------------------------------------------------------
6. Random类
*Random:是一个可以获取随机数的类
*public Random():无参构造方法
*public Random(long seed) :指定long类型的数据进行构造随机数类对象
*public int nextInt():获取随机数,它的范围是在int类型范围之内
*public int nextInt(int n):获取随机数,它的范围是在[0,n)之间
例：
//创建Random类对象
Random r = new Random() ;
int n = r.nextInt(5) ;// 获取随机数,它的范围是在[0,5)之间
7.正则表达
方法：
*public static boolean matches(String regex) :
* public String replaceAll(String regex,String replacement)使用给定的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
* public String[] split(String regex) :字符串的分割功能。按照指定的格式进行分割,分割后返回的是一个字符串数组
代码示例：
//需求：以180开头的手机号码
public class RegexDemo3 {
public static voidmain(String[] args) {
//创建键盘录入对象
Scanner sc =new Scanner(System.in) ;
//接收数据
System.out.println("请输入一个手机号码:");
String phone= sc.nextLine() ;
//定义正则规则
String regex= "1[8][0]\\d{8}" ;
boolean flag = phone.matches(regex) ;
System.out.println(flag);
}
}
代码示例：//需求:要将数字字符被替换成*
public class RegexDemo4 {
public static voidmain(String[] args) {
//定义一个字符串
String s ="hello12345World781323244454JavaEE" ;
String regex= "\\d+" ;
//定义替换的字符串
String ss ="*" ;
String result = s.replaceAll(regex, ss) ;
System.out.println("result:"+result);
}
}
代码示例
public class RegexTest2 {
public static voidmain(String[] args) {
//给定义一个字符串
String str ="18-24" ;
//利用分割功能
String[] strArray = str.split("-") ;
//要将String[]数组的字符串数据转换成int类型的数据:
int start =Integer.parseInt(strArray[0]) ;
int end = Integer.parseInt(strArray[1]) ;
//键盘录入一个年龄
Scanner sc =new Scanner(System.in) ;
//接收
System.out.println("请输入搜索的年龄:");
int age=sc.nextInt() ;
if(age>=start && age<=end) {
System.out.println("是我们要找的人...");
}else {
System.out.println("不是我们要找的...");
}
}
正则表达式的语法
字符
x x字符
\\ 反斜线字符
\t 制表符
\n 换行符
\r 回车符
字符类:
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
预定义字符类:
. 任何字符 如果本身就是. \. qq.com 写正则表达式(\\.)
\d 数字：[0-9] 写正则表达式 :\\d
\w 单词字符：[a-zA-Z_0-9]:字母大小写,数字字符 写正则表达式 \\w
边界匹配器:
^ 行的开头
$ 行的结尾
\b 单词边界尾(helloword?haha:world)
Greedy 数量词(重点)
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X字符恰好出现n次
X{n,} X字符至少出现n次
X{n,m} X字符至少出现n次,但不超过m次
8．集合
*集合的由来?
* 学生的面向对象语言,面向对象语言对事物的描述是通过对象体现的,那么需求需要来存储多个对象.
*要存储多个对象,不能使用基本类型的变量,需要使用容器类型的变量? 学习过哪些容器变量? 数组 ,字符串缓冲区(StringBuffer)
*对于字符串缓冲区来说,在内存中始终存储的是字符串,不能满足要求;数组呢,数组的长度是固定的,不符合长度编号的要求,所有Java提供了一个Collection 集合
面试题:
数组和集合的区别?
1)长度区别:
数组长度固定
集合长度可变
2)内容的区别
数组可以存储同一种类型的元素
集合可以存储多种类型的元素
3)存储类型的区别
数组:可以存储基本类型,也可以存储引用类型 String[]str={"hello","world","java",100}; 错误的
集合:只能存储引用类型
基本功能:
*添加功能:
boolean add(Object e)
*删除功能:
void clear() :删除集合中所有元素(暴力删除)
boolean remove(Object o):删除集合中的指定元素
*判断功能:
boolean contains(Object o):集合中是否包含指定的元素
*获取功能:
int size() :获取集合中的元素数
* boolean retainAll(Collection c) :交集功能: A集合对B集合取交集元素 :思考
boolean 表达的是什么意思,交集的元素是去A集合还是去B集合中？去a元素
* boolean removeAll(Collection c):删除一个集合中所有元素: 思考: 删除一个元素算是删除还是删除所有算是删除?
删除一个算删除
*转换功能:
* Object[] toArray() :将集合转换成数组
代码示例
public class CollectionDemo {
public static voidmain(String[] args) {
//创建集合对象
// Collection c = new Collecton() ;//不能实例化
Collection c = newArrayList() ;
System.out.println(c);
//booleanadd(Object e) :添加元素
/*booleanflag = c.add("hello") ;
System.out.println(flag);*/
/**
* add()方法的源码
* public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true; //只要添加就返回true
}
*/
c.add("hello");
c.add("world");
c.add("java");
System.out.println("c:"+c);
//删除功能:
// c.clear();
System.out.println("remove():"+c.remove("java"));
System.out.println("c:"+c);
//booleancontains(Object o):集合中是否包含指定的元素
System.out.println("contains():"+c.contains("android"));
System.out.println("contains():"+c.contains("hello"));
System.out.println(c.size());
//booleanisEmpty() :判断集合是否为空
System.out.println(c.isEmpty());
}
}
Iteratoriterator() :集合的迭代器方法(获取集合的迭代器)
*集合的专有遍历方式:迭代器遍历
Iterator :接口中有以下的方法:
* boolean hasNext() :如果有元素可以迭代,那么返回true,否则返回false
* Object next()返回迭代的下一个元素。
*/存储自定义对象并遍历(使用专有遍历方式)
public class IteratorDemo2 {
public static voidmain(String[] args) {
//创建集合对象:
Collectionc = new ArrayList() ;
//创建学生对象
Student s1 =new Student("张三", 27) ;
Student s2 =new Student("李四", 29) ;
Student s3 =new Student("王五", 25) ;
//添加集合中
c.add(s1) ;
c.add(s2) ;
c.add(s3) ;
//获取迭代器
Iterator it = c.iterator() ;
while(it.hasNext()){ // 如果有元素可以迭代,那么返回true,否则返回false
Students = (Student)it.next() ;
System.out.println(s.getName()+"="+s.getAge());
}
}
interface extends Collection
* 就可以使用Collection集合的功能
* Collection有两个子接口:List Set
*List集合的特点:
有序的 (存储和取出一致),可以允许重复元素
*Set集合的特点:
无序性(不能保证迭代的顺序,基于hashMap),并且元素不能重复
*/
List集合
public class ListDemo2 {
public static voidmain(String[] args) {
//创建集合对象
List list = new ArrayList() ;
//存储重复元素
list.add("hello");
list.add("world");
list.add("hello");
list.add("java");
list.add("javaee");
list.add("javaee");
list.add("android");
list.add("android");
//遍历
Iterator it = list.iterator();
while(it.hasNext()) {
Strings = (String)it.next() ;
System.out.println(s);
}
}
List集合的特有功能:
* 添加功能
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():判断是否有上一个可以迭代元素(逆向遍历)
Objectprevious():返回上一个元素
*
*逆向迭代(遍历),单独使用没意义,前提,要先正向遍历
List集合有三个子实现类:
ArrayList
底层数据结构式数组结构,查询块,增删慢
从内存角度考虑:线程不安全的,不同步的,执行效率高
多线程:synchronized:同步的意思 解决线程安全问题
sychronized(锁对象){ 同步代码
共享数据;
}
解决线程安全问题,通过同步可以解决,但是效率低了...
LinkedList
:底层数据结构式链表结构,查询慢,增删块
从内存角度考虑:线程不安全,不同步,执行效率高
Vector:
这是一个线程安全的类,
底层数据结构是数组:查询快,增删慢
线程安全的,同步,执行效率低!