一.正則表達式
正則表達式常用的語法:
A:字符
x 字符 x :任意的字符
\\ 反斜線字符 在代碼中書寫正則表達式:\------>用兩個\\代表一個反斜線
\t 製表符 ('\u0009')
\n 新行(換行)符 ('\u000A') IO流中要寫入換行符號:windows "\r\n"
\r 回車符 ('\u000D')
B:字符類
[abc] a、b 或 c(簡單類)
[^abc] 任何字符,除了 a、b 或 c(否定)
[a-zA-Z] a 到 z 或 A 到 Z,兩頭的字母包括在內(範圍) :當前字母大小均可
C:預定義字符類
. 任何字符 郵箱裏面:如果本身就是.,那麼在寫正在表達式的時候,\.將當前.轉義
\d 數字:[0-9] \d在正則表達式應用的時候:[0-9]--->\\d
\w 單詞字符:[a-zA-Z_0-9]:簡單一些字符串,單詞字符(規則:數字或者字母)
javascript:[a-zA-Z0-9]
D:邊界匹配器
^ 行的開頭
$ 行的結尾
\b 單詞邊界 :
hello;world:haha:xixi
E:Greedy 數量詞
X? X,一次或一次也沒有
X* X,零次或多次
X+ X,一次或多次
X{n} X,恰好 n 次
X{n,} X,至少 n 次
X{n,m} X,至少 n 次,但是不超過 m 次
a、b 或 c(簡單類)
[^abc] 任何字符,除了 a、b 或 c(否定)
[a-zA-Z] a 到 z 或 A 到 Z,兩頭的字母包括在內(範圍) :當前字母大小均可
C:預定義字符類
. 任何字符 郵箱裏面:如果本身就是.,那麼在寫正在表達式的時候,\.將當前.轉義
\d 數字:[0-9] \d在正則表達式應用的時候:[0-9]--->\\d
\w 單詞字符:[a-zA-Z_0-9]:簡單一些字符串,單詞字符(規則:數字或者字母)
javascript:[a-zA-Z0-9]
D:邊界匹配器
^ 行的開頭
$ 行的結尾
\b 單詞邊界 :
hello;world:haha:xixi
E:Greedy 數量詞
X? X,一次或一次也沒有
X* X,零次或多次
X+ X,一次或多次
X{n} X,恰好 n 次
X{n,} X,至少 n 次
X{n,m} X,至少 n 次,但是不超過 m 次
正則表達式的校驗功能:(校驗QQ號碼)
public class RegexDemo2 {
public static void main(String[] args) {
//創建鍵盤了錄入對象
Scanner sc = new Scanner(System.in) ;
//錄入並接收數據
System.out.println("請您輸入QQ號碼: ");
String QQ = sc.nextLine() ;
boolean flag = checkQQ(QQ) ;
System.out.println("flag: "+flag);
}
public static boolean checkQQ(String qq){
/*//定義正則規則
String regex = "[1-9][0-9]{4,9}" ;
//public boolean matches(String regex)告知此字符串是否匹配給定的正則表達式。
boolean flag = qq.matches(regex) ;
return flag ;*/
//直接返回
return qq.matches("[1-9]\\d{4,9}");
}
}
分割功能:
package org.westos_13_正則表達式;
import java.util.Scanner;
/**
* public String[] split(String regex)根據給定正則表達式的匹配拆分此字符串
* 返回值類型是一個字符串數組類型
* */
public class RegexDemo1 {
public static void main(String[] args) {
String ages = "18-24" ;
//定義正則規則
String regex = "-" ;
String[] strArray = ages.split(regex);
//轉換int類型的數據
int startAge = Integer.parseInt(strArray[0]);
int endAge = Integer.parseInt(strArray[1]);
//創建鍵盤鍵盤錄入一個年齡,屬於int類型的數據
Scanner sc = new Scanner(System.in);
//錄入並接收數據
System.out.println("請您輸入一個年齡:");
int age = sc.nextInt();
//判斷是否符我們要找的一類人
if(age>=startAge && age<= endAge) {
System.out.println("年齡符合,交個朋友吧....");
}else {
System.out.println("對不起,你們不合適....");
}
}
}
public class RegexDemo2 {
public static void main(String[] args) {
//定義個字符串
String str1 = "aa,bb,cc" ;
//使用分割功能
String[] strArray1 = str1.split(",") ;
//遍歷字符串數組
for(int x = 0 ; x < strArray1.length; x ++){
System.out.println(strArray1[x]);
}
System.out.println("------------------");
//字符串:
String str2 = "aa bb cc" ;
//使用切割功能:
String[] strArray2 = str2.split(" +") ;
for(int x = 0 ; x <strArray2.length ; x++){
System.out.println(strArray2[x]);
}
System.out.println("--------------------");
String str3 = "aa.bb.cc" ;
//分割功能
String[] strArray3 = str3.split("\\.") ;
for(int x =0 ; x<strArray3.length ; x ++){
System.out.println(strArray3[x]);
}
//硬盤上的路徑表現形式:用兩個反斜線代表一個反斜線
//E:\\JavaSE\\JavaCode\\day13
String str4 = "E:\\JavaSE\\JavaCode\\day13" ;
//使用分割功能
String[] strArray4 = str4.split("\\\\") ;
for(int x = 0 ; x <strArray4.length ; x ++){
System.out.println(strArray4[x]);
}
}
}
關於模式和匹配器的使用:獲取功能
模式和匹配器基本使用順序
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexDemo4 {
public static void main(String[] args) {
//public static Pattern compile(String regex)將給定的正則表達式編譯成一個模式對象
//1)獲取模式對象(通過正則規則)
Pattern p = Pattern.compile("a*b") ;
//2)通過模式獲取匹配器對象,(將一個字符串類型的數據)
Matcher m = p.matcher("aaaaaab") ;
//3)調用Match(匹配器類)中的:public boolean matches():判斷當前用戶錄入的字符串是否和當前的正則規則匹配
boolean flag = m.matches() ;
System.out.println("flag:"+flag);
System.out.println("----------------------------");
//上述寫法非常麻煩,要獲取模式對象Pattern還要獲取匹配器對象:Matcher,然後通過matches()方法返回一個結果
//以後可以使用下面這種格式
//定義一個正則規則
String regex = "a*b" ;
//指定某一個字符串
String str = "aaaaaaab" ;
//使用String類的功能
//使用當前給定的字符串調用public boolean matchers(String regex)
boolean flag2 = str.matches(regex) ;
System.out.println("flag2: "+flag2);
}
}
String類中的替換功能:和正則表達式有關係
public String replaceAll(String regex,String replacement)
使用給定的 replacement 替換此字符串所有匹配給定的正則表達式的子字符串。
public class RegexDemo3 {
public static void main(String[] args) {
//定義一個字符串:
String str = "helloword123JavaSE45678Javaweb" ;
//需求:讓當前這個字符串中的數字不顯示出來
//定義當前大串中數字定義正則規則
//String regex = "[0-9]+" ;
String regex = "\\d+" ;
String s = "*" ;
//public String replaceAll(String regex,String replacement)
String result = str.replaceAll(regex, s) ;
System.out.println("result:"+result);
}
}
練習:
/**
* 我有如下一個字符串:"91 27 46 38 50"
請寫代碼實現最終輸出結果是:"27 38 46 50 91"
分析:
1)定義這個字符串
2)使用分割功能分割成一個字符串數組
3)如何得到一個int類型數組:動態初始化定義int數組 int[] arr = new int[字符串數數組.length] ;
4)遍歷int數組
獲取每一個元素:arr[x] = Integer.parseInt(字符串數組對象[x])
5)排序:Arrays數組工具類型快速排序:sort(arr)
6)再去遍歷int類型數組獲取每一個元素,用字符串緩衝區來進行拼接
7)輸出字符串
* @author Apple
*/
public class RegexTest {
public static void main(String[] args) {
//定義一個字符串
String str = "91 27 46 38 50" ;
//使用分割功能
String[] strArray = str.split(" ") ;
//定義一個int類型的數組,動態初始化
int[] arr = new int[strArray.length] ;
//遍歷int類型的數組
for(int x = 0 ; x < arr.length ; x ++){
arr[x] = Integer.parseInt(strArray[x]) ;
}
//使用Arrays數組工具類型進行操作
Arrays.sort(arr) ;
//創建StringBuilder緩衝區對象
StringBuilder sb = new StringBuilder() ;
//再去遍歷int類型的數組,目的使用爲了拼接
for(int x = 0 ; x < arr.length ; x ++){
//使用追加功能
sb.append(arr[x]).append(" ") ;
}
//要將字符串緩衝轉換成String類型,並且去除兩端空格
String result = sb.toString().trim() ;
System.out.println("result:"+result);
}
}
二. 集合
集合的由來:
java語言是一種面嚮對象語言,面嚮對象語言對事物的描述是通過對象體現出來的,那麼存儲很多個對象,就需要使用容器變量進行存儲
目前:學習過哪些容器變量呢?
數組, StringBuffer/StringBuilder,對於數組來說,數組的長度是固定的,不符合實際需求(長度不可變);對於StringBuffer來說始終在內存中返回
的是字符串類型,也不滿足元素類型變化的要求;所以,Java就提供了一個技術:集合!
集合的框架:
集合框架是爲表示和操作集合而規定的一種統一的標準的體系結構。任何集合框架都包含三大塊內容:對外的接口、接口的實現和對集合運算的算法。
接口:即表示集合的抽象數據類型。接口提供了讓我們對集合中所表示的內容進行單獨操作的可能。
實現:也就是集合框架中接口的具體實現。實際它們就是那些可複用的數據結構。
算法:在一個實現了某個集合框架中的接口的對象身上完成某種有用的計算的方法,例如查找、排序等。這些算法通常是多態的,因爲相同的方法可以在同一個接口被多個類實現時有不同的表現。
集合繼承框架(圖片來自百度)
面試題:
集合和數組的區別?
1)長度的區別:
數組:長度是固定的;
集合:長度是可變的
2)存儲數據類型的區別:
數組:可以存儲引用類型,可以存儲基本數據類型
集合:只能存儲引用類型
3)存儲元素的區別
數組:在同一個數組中,只能存儲同一種數據類型的元素;
集合:可以 存儲多種數據類型的元素;
Collection: 表示一組對象,這些對象也稱爲 collection 的元素。一些 collection 允許有重複的元素,而另一些則不允許。
一些 collection 是有序的,而另一些則是無序的。JDK 不提供此接口的任何直接 實現:它提供更具體的子接口(如 Set 和 List)實現
所有通用的 Collection 實現類(通常通過它的一個子接口間接實現 Collection)應該提供兩個“標準”構造方法:一個是 void(無參數)構造方法,用於創建空 collection;另一個是帶有Collection 類型單參數的構造方法,用於創建一個具有與其參數相同元素新的 collection。
Collection的一些功能
添加功能:
boolean add(Object e):給集合中添加指定的元素
boolean addAll(Collection c):添加一個集合中的所有元素
刪除功能:
void clear():刪除一個集合中的所有元素,暴力刪除,(不建議使用)
boolean remove(Object o):刪除一個集合中的指定元素
boolean removeAll(Collection c):刪除一個集合中的所有元素?思考:刪除所有算是刪除還是刪除一個算是刪除?
判斷功能:
boolean contains(Object o):判斷一個集合中是否包含指定的單個元素
boolean containsAll(Collection c):判斷一個集合中是否另一個集合;思考:是包含一個元素算是包含還是包含所有.
boolean isEmpty():判斷集合是否爲空,如果爲空,則返回true
交集功能:
boolean retainAll(Collection c):思考:A集合給B集合做交集,交集的元素去哪裏?返回值boolean表達什麼意思?
獲取功能;
int size():獲取集合中的元素數
Iterator<E> iterator():迭代器
轉換功能:
Object[] toArray():將集合轉換成數組
關於面試題(前面有提到):
數組中有沒有length(),String類中有沒有length(),集合中有沒有length()?
數組:length屬性
String:length()
集合中:size()方法可以獲取集合長度
創建Collcetion集合對象:
Collection c = new Collection() ;(錯誤的)JDK 不提供此接口的任何直接 實現:它提供更具體的子接口(如 Set 和 List)實現
Collection c = new ArrayList() ;
功能:
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
public static void main(String[] args) {
//創建對象
Collection c = new ArrayList();
System.out.println(c); //[] 底層重寫了toString();
//boolean add(Object e):給集合中添加指定的元素
c.add("hello") ;
c.add("world") ;
c.add("Java") ;
c.add("宮本");
System.out.println(c); //[hello, world, Java, 宮本]
//c.clear() ;//暴力刪除(不建議使用)
//boolean remove(Object o):刪除一個集合中的指定元素
System.out.println("remove:"+c.remove("宮本")) ;//remove:true
System.out.println(c);//[hello, world, Java]
System.out.println("remove:"+c.remove("love"));//remove:false沒有刪除的元素返回false
//boolean contains(Object o):判斷一個集合中是否包含指定的單個元素
System.out.println("contains:"+c.contains("宮本"));//contains:false 前面削了宮本,沒了
System.out.println("contains:"+c.contains("Java"));//contains:true
//boolean isEmpty():判斷集合是否爲空,如果爲空,則返回true
System.out.println("isEmpty:"+c.isEmpty());
//int size():獲取集合中的元素數
System.out.println("集合中的元素數:"+c.size());//集合中的元素數:3
}
}
高級功能:
package org.westos_13_集合;
/**
*集合的高級功能:
* boolean addAll(Collection c):添加一個集合中的所有元素
* boolean removeAll(Collection c):刪除一個集合中的所有元素 思考:刪除所有算是刪除還是刪除一個算是刪除? 刪除一個算是刪除
* boolean containsAll(Collection c):判斷一個集合中是否另一個集合;思考:是包含一個元素算是包含還是包含所有
* boolean retainAll(Collection c):思考:A集合給B集合做交集,交集的元素去哪裏?返回值boolean表達什麼意思?
*
* */
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo1 {
public static void main(String[] args) {
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
// 給c1,c2集合添加元素
c1.add("abc1");
c1.add("abc2");
c1.add("abc3");
c1.add("abc4");
/*
* c2.add("abc1") ; c2.add("abc2") ; c2.add("abc3") ;
*/
//c2.add("abc4") ;
c2.add("abc5");
c2.add("abc6");
c2.add("abc7");
//boolean addAll(Collection c):添加一個集合中的所有元素
System.out.println("addAll:"+c1.addAll(c2));//addAll:true
System.out.println("c1:"+c1);//c1:[abc1, abc2, abc3, abc4, abc5, abc6, abc7]
System.out.println("c2:"+c2);//c2:[abc5, abc6, abc7]
//boolean removeAll(Collection c):刪除一個集合中的所有元素
//System.out.println("removeAll:"+c1.removeAll(c2));//removeAll:true
//boolean containsAll(Collection c):判斷一個集合中是否另一個集合
System.out.println("containsAll:"+c1.containsAll(c2));//包含所有算是包含
//boolean retainAll(Collection c):A集合給B集合做交集
System.out.println("retianAll:"+c1.retainAll(c2));//retianAll:true
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
}
}
面試題:
A集合對B集合取交集,那麼交集的元素去A集合裏面了,並且返回值boolean表達的意思是A集合中的元素是否發生變化,如果發生變化,就返回true;否則,false
import java.util.ArrayList;
import java.util.Collection;
/**
* Object[] toArray():將集合轉換成數組
* 需求:給集合中添加String類型的元素,遍歷集合
* */
public class CollectionDemo2 {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("要是能重來") ;
c.add("我要選李白") ;
c.add("宮本武藏") ;
c.add("小短腿") ;
//將集合轉換成數組
Object[] obj = c.toArray();
//遍歷
for(int x =0;x<obj.length;x++) {
System.out.println(obj[x]);
/*需求:獲取集合中元素的同時,獲取集合中每一個元素的字符串長度
要獲取長度,就需要使用length(),該方法屬於String類的特有功能*/
String s = (String) obj[x];//向下轉型
System.out.println(s+"----"+s.length());
}
}
}
集合的專有遍歷方式:使用集合自己本身迭代功能遍歷集合中的元素
Iterator iterator():迭代器
迭代器是接口不能是類的原因:每一個集合都有自己的特點,而且各自都有自己的遍歷方式
而這麼多集合類的方法需要被聲明出來,所以將Iterator定義爲一個接口
成員方法:Object next()返回迭代的下一個元素:獲取功能(通過內部類獲取)
boolean hasNext():判斷一個集合中是否有下一個可以迭代的元素:判斷功能
package org.westos_13_集合迭代器;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo1 {
public static void main(String[] args) {
//創建集合對象
Collection c = new ArrayList();
//添加元素
c.add("hello");
c.add("world");
c.add("javase");
//迭代器
Iterator it = c.iterator();//底層使用ArrayList中的匿名內部類的形式:接口多態的形式
/*Object next = it.next();//返回的是Object類
System.out.println(next);*/
/*當集合中的元素獲取完了,再去調用next()方法,那麼就出現java.util.NoSuchElementException:沒有這樣的元素異常!
加上一個判斷就可以防止出現異常!*/
//boolean hasNext():判斷一個集合中是否有下一個可以迭代的元素:判斷功能
//因爲不知道當前集合的元素個數,所以用while循環
while(it.hasNext()) {
//System.out.println(it.next());
String s = (String)it.next();
System.out.println(s+"---"+s.length());
}
}
}
練習:
package org.westos_13_集合練習;
import java.util.ArrayList;
import java.util.Collection;
/**
* 需求:有5個學生,每一個學生有自己的信息(姓名,年齡等等),將5個學生的信息遍歷出來!
* 使用集合的轉換功能去遍歷學生信息
*
* 1)創建集合對象
* 2)創建5個學生對象
* 3)使用集合添加5個學生對象
* 4)將集合轉換成數組:Object[] toArray() ;
* 5)遍歷數組
*
* */
public class CollectionTset {
public static void main(String[] args) {
// 創建集合對象
Collection c = new ArrayList();
//創建5個學生對象
Student s1 = new Student("虞姬", 185) ;
Student s2 = new Student("魯班七號", 152) ;
Student s3 = new Student("李白", 180) ;
Student s4 = new Student("宮本", 178) ;
Student s5 = new Student("太乙", 150) ;
//給集合中添加元素
c.add(s1) ;
c.add(s2) ;
c.add(s3) ;
c.add(s4) ;
c.add(s5) ;
//將集合轉換成數組
Object[] objs = c.toArray();
//遍歷
for(int x=0;x<objs.length;x++) {
Student s = (Student) objs[x];
System.out.println(s.getName()+"---"+s.getHeight());
}
}
}
List集合:
package org.westos_13_List;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
/**
* 用List集合存儲字符串類型的元素,並遍歷:迭代器遍歷
*
**/
public class ListDemo1 {
public static void main(String[] args) {
List list = new ArrayList();
//添加元素
list.add("hello");
list.add("world");
list.add("world");//可以重複
list.add("Java");
Iterator it =list.iterator();
//遍歷
while(it.hasNext()) {
String s = (String)it.next();
System.out.println(s);
}
}
}
List集合的特有功能:
添加功能:
void add(int index, Object element)在列表的指定位置插入指定元素
刪除功能:
Object remove(int index)移除列表中指定位置的元素,返回被刪除的元素
獲取功能:
ListIterator listIterator():列表迭代器:List集合的專有遍歷方式
Object get(int index)返回列表中指定位置的元素。
替換
set(int index,Object element)用指定元素替換列表中指定位置的元素
package org.westos_13_List;
import java.util.ArrayList;
import java.util.List;
public class ListDemo2 {
public static void main(String[] args) {
List list = new ArrayList();
//添加
list.add("hello") ;
list.add("world") ;
list.add("java") ;
//void add(int index, Object element)在列表的指定位置插入指定元素,在指定位置前面插入一個新的元素
list.add(2, "javase") ;
System.out.println(list);
//Object remove(int index)移除列表中指定位置的元素,返回被刪除的元素
/*list.remove(2);
System.out.println(list);*/
// set(int index,Object element)用指定元素替換列表中指定位置的元素
System.out.println("set:"+list.set(1, "EDG"));//set:world,返回被替換的元素
}
}
練習:
package org.westos_13_List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
*
* 問題?
* 我有一個集合,如下,請問,我想判斷裏面有沒有"world"這個元素,
* 如果有,我就添加一個"javaee"元素,請寫代碼實現
* 併發(同一個時間點),並行(同一個時間段)
* java.util.ConcurrentModificationException:併發修改異常:當方法檢測到對象的併發修改,但不允許這種修改時,拋出此異常。
* 原因:當前我們用迭代器去遍歷元素,使用集合添加的元素,對於迭代器不知道集合添加了這個元素,所以會發生這個異常
* 描述:使用迭代器去遍歷集合,是不能直接集合添加元素!
* 解決方案:
* 1)使用迭代器遍歷集合,使用迭代器添加元素
* 2)使用集合遍歷,使用集合添加元素
* */
public class ListTest {
private static Object s;
public static void main(String[] args) {
List list = new ArrayList();
//給集合添加元素
list.add("Hello");
list.add("world");
list.add("Java");
/*Iterator it = list.iterator();
while (it.hasNext()) {
String s = (String) it.next();
if("world".equals(s)) {
list.add("Javaee");
}
}*/ //這種方法會導致併發異常
/*方案1:使用List集合中的專有遍歷方式:列表迭代器有添加功能:add(Object obj)
將指定的元素插入到列表中(指定元素後面插入),使用迭代器添加元素*/
//Iterator it = list.iterator() ; 該迭代器中沒有添加功能
/*ListIterator it = list.listIterator();
while (it.hasNext()) {
String s = (String) it.next();
if ("world".equals(s))
{
it.add("Javaee");
}
}
System.out.println("list:"+list);*///list:[Hello, world, Javaee, Java]
// 方案2:使用集合遍歷(普通for循環size()和get()相結合),使用集合添加元素
for (int x = 0; x < list.size(); x++) {
String s = (String) list.get(x);
if ("world".equals(s)) {
list.add("Javaee");
}
}
System.out.println("list:" + list);//list:[Hello, world, Java, Javaee]
}
}