常用类/正则表达式/枚举

最新推荐文章于 2024-08-23 16:57:39 发布

沈念

最新推荐文章于 2024-08-23 16:57:39 发布

阅读量4.5k

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/Seulementzh1010/article/details/78949793

版权

java 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

2017.12.30

学习内容

1.常用类；

2.正则表达式；

3.枚举。

一.常用类

1.Math类（final类）

其成员变量及成员方法时静态的。

eg:

2.Random类：

常用方法：（1）public int nextInt(int bound) 返回从0（包含）到bound（不包含）的一个“伪随机”整数值；

（2）public boolean nextBoolean() 返回一个“伪随机”的boolean值（true or false）

eg:

3.System类

内部包含in（标准输入流，即键盘输入）、out（标准输出流，即显示器）、err（标准错误输出流，即显示器）成员变量；

成员方法：System.arraycopy();//数组拷贝

System.exit(0); //退出程序

System.gc(); //请求系统进行垃圾回收，垃圾回收时，会先调用finalize()方法，释放非java资源。

System.currentTimeMillis();//以毫秒为单位返回从1970年1月1日午夜到当前时间的毫秒数

eg:

eg:int[] a = {2,4,1,6};
int[] b = new int[5];
System.arraycopy(a,2,b,1,2);//将a数组从下标为2开始的数拷贝到数组b中下标为1的数，拷贝两个数。

4.Runtime类（使应用程序与其运行的环境相关联）

通过使用getRuntime()静态方法获得实例。

exec(String command)在单独的进程中执行指定的字符串命令，该方法返回Process对象，使用Process对象的destroy（）方法杀掉进程；

eg:

package runtime;
import java.io.IOException;
import java.util.Scanner;
public class RuntimeDemo {

public static void main(String[] args) {
Runtime rt=Runtime.getRuntime();//
rt.gc();//请求JVM进行垃圾回收
System.out.println("当前JVM的内存总量是："+rt.totalMemory()+"字节");
System.out.println("JVM试图使用的最大内存量："+rt.maxMemory());
System.out.println("当前JVM的空闲内存量："+rt.freeMemory());
try {
rt.exec("notepad");
Process p=rt.exec("D:\\2345Downloads\\Software\\CloudMusic\\cloudmusic.exe");//打开网易云进程
Scanner scan=new Scanner(System.in);
System.out.println("要关闭网易云吗？y/n");
String choice=scan.next();
if("y".equals(choice)){
p.destroy();
}

} catch (IOException e) {

e.printStackTrace();
}
}

}

5.Data与SimpleDataFormat类

eg:

package common;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {

public static void main(String[] args) {
Date date=new Date(); //创建日期对象
System.out.println(date);
SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS"); // 传递日期模版，实例化SimpleDateFormat对象
System.out.println("现在时刻："+sdf.format(date));
}
}

6.Calenday类（抽象类）

用于设置和获取日期/时间数据的特定部分

eg:package calendar;
import java.util.Calendar;

public class CalendarDemo {
public static void main(String[] args) {
Calendar c=Calendar.getInstance();
System.out.println("当前第几个月："+(c.get(Calendar.MONTH)+1));
System.out.println("当前月的第几天："+c.get(Calendar.DAY_OF_MONTH));
System.out.println("当前周的第几天："+(c.get(Calendar.DAY_OF_WEEK)-1));
}
}

二.正则表达式：（regex）

(1) 使用字符来描述、匹配一系列符合某个句法规则的字符串。用于匹配、切割、替换、获取字符串

在Java中反斜线”\”有三种含义：

1. 反斜线后面可以加特定字符，组成所谓的“转义字符”。eg: \n \t

2. 用于取消元字符的意义，使元字符变为普通字符。eg: “\\” 代表”\”。

3. 用于组成正则表达式中的元字符。

eg: “\d” 在正则表达式中代表“匹配一个数字字符”。

4.正则表达式中的问号?有两种作用：

第一种作用：重复前面表达式0次或1次。

第二种作用：在表示次数的元字符后加上?

代表取消默认的贪婪匹配模式，变为“非贪婪匹配模式”。

（2）String类对正则表达式的支持

1. public booleanmatches(String regex)

判断字符串是否与给定的正则表达式匹配。

2. public String replaceAll(Stringregex,String replacement) 字符串替换

3. public String[]split(String regex) 字符串拆分

eg1:

//String

package regex;

public class StringRegex {

public static void main(String[] args) {
String str="我我…我..喜……喜欢…欢…你";
if(str.matches("\\w+")){
System.out.println("匹配成功！");
}
System.out.println("替换后的字符串为："+str.replaceAll(str,"我喜欢你"));

String country="成都|西安|昆明|珠海";
String[] array=country.split("\\|");
for(String c:array){
System.out.print(c+" ");
}
}

}

eg2:

package regex;

public class GreedyRegex {

public static void main(String[] args) {
String str="cfffff";
System.out.println("贪婪模式匹配: "+str.replaceAll("cf+","#")); // "贪婪匹配"
System.out.println("非贪婪模式匹配: "+str.replaceAll("cf+?","#"));
}

}

(3)Pattern类与Matcher类

1、都在java.util.regex包中定义；

2、Pattern类的对象代表正则表达式编译之后的对象；Matcher类主要用于执行验证。

eg：

package regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatch {

public static void main(String[] args) {
String birthday="1994-02-25";
String regex="\\d{4}-\\d{2}-\\d{2}";
Pattern pat=Pattern.compile(regex); // 将正则表达式封装到Pattern对象中
Matcher mat=pat.matcher(birthday); // 创建一个匹配器Matcher,该Matcher对象可以根据正则表达式判断传入的字符串是否符合要求
if(mat.matches()){
System.out.println("匹配成功！");
}else{
System.out.println("匹配失败...");
}

}

}

三.枚举类型（自动继承java.lang.Enum类（该类继承了Object类）。）

（1）使用一组常量值来表示特定的数据集合，该集合中数据的数目确定（通常较少），且这些数据只能取预先定义的值。

声明格式：

[public] enum枚举类型名称{

枚举对象1,枚举对象2,…,枚举对象n ;

}

（2）获取枚举对象的两种方法：

方法一：取得单个枚举对象

枚举.对象名

方法二：取得全部枚举对象

枚举.values()

注意：枚举.values()返回的是一个对象数组，可以通过遍历该对象数组获取所有枚举对象。

eg：

package enumdemo;
public class TestColor {
public static void main(String[] args) {
ColorEnum r=ColorEnum.RED;
System.out.println(r);
System.out.println("遍历所有枚举对象：");
for(ColorEnum c:ColorEnum.values()){ //枚举.values()取得全部枚举对象
System.out.print(c+" ");
}

}

}

2017.12.31

学习目标：

1、集合概念与框架结构

2、List集合及其实现类

3、迭代器(Iterator)的使用

4、Set集合

一、集合概念与框架结构

（1）集合概念：JavaAPI所提供的一系列类的实例，可以用于动态存放多个对象；

Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中；

特点：长度不固定，只能存储引用类型对象

二、List集合及其实现类

List 接口：存放的元素有序且允许有重复的集合接口。

Listj集合类：ArrayList及LinkedList

新增方法：

public Objectget( int index); // 返回列表中的元素数

publicObject add( int index, Object element); // 在列表的指定位置插入指定元素 . 将当前处于该位置的元素（如果有的话）和所有后续元素向右移动

publicObject set( int index, Object element) ; // 用指定元素替换列表中指定位置的元素

publicObject remove( int index); // 移除列表中指定位置的元素

public ListIterator listIterator () // 返回此列表元素的列表迭代器

实现类：ArrayList

优点：使用索引快速定位对象

缺点：元素做删除或插入速度较慢

eg：package list;
import java.util.*;
public class ArrayListDemo {

public static void main(String[] args) {
ArrayList<String> list=new ArrayList<String>();
list.add("apple");
list.add("pear");
list.add("watermelon");
list.add("pear"); // List可以添加重复元素
list.add("apple"); // List可以添加重复元素
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+" "); // get(int index)方法是List接口扩展的方法
}
System.out.println();
System.out.println("**********foreach循环遍历**********");
for(String str:list){
System.out.print(str+" ");
}
System.out.println();

System.out.println("包含pear吗？"+list.contains("pear"));
System.out.println("删除之前的元素个数："+list.size());
list.remove("pear");
System.out.println("删除之后的元素个数："+list.size());
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+" "); // get(int index)方法是List接口扩展的方法
}
}
}

实现类：LinkedList(使用双向链表实现的集合。)

优点：对频繁的插入或删除元素有较好的效率

缺点：查询元素时，效率低，因为要从第一个元素查找

eg:

package list;
import java.util.LinkedList;

public class LinkedListDemo {

public static void main(String[] args) {
System.out.println("模拟栈数据结构(先进后出FILO)：");
LinkedList<String> list=new LinkedList<String>();
list.push("A");
list.push("B");
list.push("C");
System.out.println(list.pop());
System.out.println(list.pop());
System.out.println(list.pop());
System.out.println("模拟队列数据结构(先进先出FIFO)：");
list.add("A");
list.add("B");
list.add("C");
System.out.println(list.removeFirst());
System.out.println(list.removeFirst());
System.out.println(list.removeFirst());
}

}

三、迭代器的使用

（1）概念： Iterator 是专门的迭代输出接口。所谓的迭代输出就是将元素进行判断，判断是否有内容，如果有内容则把内容取出。

（2）Iterator对象称作迭代器，用以方便的实现对集合内元素的遍历操作。

（3）格式：

Iterator it = coll.iterator ();

while( it.hasNext ()){

it.next ();

}

eg：package iterator;
import java.util.*;
public class IteratorDemo {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
Collections.addAll(list,"China","America","Japan","China","France");
Iterator<String> iter=list.iterator(); // 返回List集合的迭代器
// 通过迭代器遍历集合
while(iter.hasNext()){
System.out.print(iter.next()+" ");
}
}
}

（4） Iterator 接口中定义了如下方法：

boolean hasNext (); // 判断游标右边是否有元素

Object next(); // 返回游标右边的元素并将游标移动到下一个位置

（5）泛型：

1、定义：对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。

2、好处：解决了类型安全的问题 ( 运行期出现“ java.lang.ClassCastException ”异常 )

3、受限泛型

a. 设置上限

类名称<? extends 上限类> //只能接收上限类对象或其子类对象

b.设置下限

类名称<? super 下限类> //接收下限类对象或其父类对象

eg：package generic;
import java.util.*;
public class GenericDemo {

public static void main(String[] args) {
ArrayList<String> list=new ArrayList<String>();
list.add("pear");
list.add("watermelon");
for(String data:list){
System.out.print(data+" ");
}

method(list);
method(new ArrayList<Object>());
}

public static void method(List<? super String> list){
List<String> temp=(List<String>)list;
temp.add("123");
}
}

四、 Set接口：存放的元素不包含重复元素的集合接口。

1. HashSet ：散列存放(不保存元素的加入顺序。)

注意：对于要存放到 HashSet 集合中的对象，对应的类可以重写 hashCode (Object obj ) 方法和 equals() 以实现对象相等规则的编写。

存储原理：根据每个对象的哈希码值(调用hashCode()获得)用固定的算法算出它的存储索引，把对象存放在一个叫散列表的相应位置(表元)中：

如果对应的位置没有其它元素，就只需要直接存入。

如果该位置有元素了，会将新对象跟该位置的所有对象进行比较(调用equals())，以查看是否已经存在了：还不存在就存放，已经存在就不存储。

eg：

//Student类

package set.hashset;
public class Student {
private String name;
private int age;
public Student(){
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}

@Override
public int hashCode() {
return this.age*2;
}

@Override
public boolean equals(Object obj) {
if(obj==null){
return false;
}
if(obj==this){
return true;
}
if(!(obj instanceof Student)){
return false;
}
Student stu=(Student)obj;
if(this.name!=null && this.name.equals(stu.name) && this.age==stu.age){
return true;
}
return false;
}

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 "Student [name=" + name + ", age=" + age + "]";
}

}

//Test类

package set.hashset;
import java.util.HashSet;
public class PersonHashSet {

public static void main(String[] args) {
HashSet<Person> set=new HashSet<Person>();
set.add(new Student("小华",20));
set.add(new Student("小明",22));
set.add(new Student("小李",21));
set.add(new Student("小华",20));
set.add(new Student("小华",20));

for(Student stu:set){
System.out.println(stu);
}

}

}

2.TreeSet：有序存放

注意：可以对加入其中的元素进行排序。但前提是，必须指定排序规则。

构造方法： public TreeSet()

如果使用TreeSet的无参构造实例化TreeSet集合，则加入到TreeSet集合中的元素所对应的类必须实现java.lang.Comparable<T>接口，复写其中的int compareTo(T o)方法，并在方法中编写排序规则。

在Comparable<T>接口的compareTo(T o)方法中，指定排序规则(以升序为例)：

publicintcompareTo(Girl girl)｛

if(this.xxx>girl.xxx){

return 1;

}else if(this.xxx<girl.xxx){

return -1;

}else{

return 0;

}

｝

TreeSet比较排序的过程，已经对重复元素去重了。

eg:

//Boy类

package set.treeset;

public class Boy implements Comparable<Boy>{
private String name; // 姓名
private int face; // 颜值
private double money; // 经济

public Boy() {

}

public Boy(String name, int face, double money) {
super();
this.name = name;
this.face = face;
this.money = money;
}

// 在该方法中指定排序规则
@Override
public int compareTo(Boy b) {
System.out.println("*****************************");
if(girl==null){
return 1;
}
if(this.face>b.face){
return -1;
}else if(this.face<b.face){
return 1;
}else{
if(this.money>b.money){
return -1;
}else if(this.money<b.money){
return 1;
}else{
return this.name.compareTo(b.name);
}
}

}

@Override
public String toString() {
return "Boy [name=" + name + ", face=" + face + ", money=" + money
+ "]";
}
}

//Test类：

package set.treeset;
import java.util.TreeSet;
public class PersonTreeSet {

public static void main(String[] args) {
TreeSet<Boy> set=new TreeSet<Boy>();
set.add(new Boy("南宫",80,20.5));
set.add(new Boy("慕寒",60,80.9));
set.add(new Boy("碧海",95,2.5));
set.add(new Boy("落尘",80,30.5));
set.add(new Boy("沐阳",80,30.5));
for(Boy bl:set){
System.out.println(b);
}

}

}