正则表达式/Calendar/集合/迭代器
一:二分查找:
(1) 前提条件:数组必须是有序的,(已经是一个排好序的数组)
(2) 思想:猜想中间索引,这样可以将数组减半
二:选择排序:从0索引开始,依次与后面的每个索引处的值进行比较,每次比较后,较小的数放在前面.第一轮比较完成后,最小值出现在了最小索引处.
#选择排序与二分查找的综合应用:
packageBinaryDemo_01;
/**
* 先初始化一个无序数组,然后只用选择排序将其由小到大排序,之后再进行二分法查找(二分法查找只能是针对已经排好序的数组)
* */
public class BinaryDemo01 {
public static void main(String[] args) {
int []array={23,9,45,11,42,18};
SortArray(array);
System.out.println("排序后的数组为:");
PrintArray(array);
int indexof=BinarySerach(array,18);
System.out.println("最后获取该元素的索引:" + indexof);
}
public static void SortArray(int []ar){//冒泡法将数组进行排序
for(int i=0;i<ar.length-1;i++){
for(int j=i+1;j<ar.length;j++){
if(ar[i]>ar[j]){
int temp=ar[j];
ar[j]=ar[i];
ar[i]=temp;
}
}
}
}
public static void PrintArray(int []ar2){
System.out.print("[");
for(int i=0;i<ar2.length;i++){
if(i==ar2.length-1){
System.out.println(ar2[i] + "]");
}
else{
System.out.print(ar2[i] + ",");
}
}
}
public static int BinarySerach(int []ar3,int value){
int begain=0;
int end=ar3.length-1;
int middle=(begain+end)/2;
while(ar3[middle] != value){
if(ar3[middle]<value){//实际传入的值大于中间索引处的值,begain加1
begain +=1;
}
else if(ar3[middle]>value){//实际传入的值小于中间索引处的值,end减1
end -=1;
}
else if(begain>end){//如果没有找到该元素,则返回-1
return -1;
}
middle=(begain+end)/2;//再次获得中间位置处的索引
}
return middle;
}
}
二:Arrays类:
(1) 此类包含用来操作数组（比如排序和搜索）的各种方法(针对数组操作的工具类)
(2) 常用的几个方法:
public static String toString(int[] a):将任意类型的数组以字符串形式显示出来!
public static void sort(int[] a):快速排序:(将给定数组中元素升序排序)
publicstatic int binarySearch(int[] a, int key):当前int数组一定是有序数组, 使用二分搜索法来搜索指定的int 型数组，以获得指定的值
(3) 将其他类型转换为String类型的三种方法:
1. String类的toString()方法
2. String类的valueof()方法
3. String类的有参构造:String Str=new String(int[]arr/char[]chr/short[]shr)参数可以是任意类型
#对字符串中的字母进行排序:
packageArraysSortDemo;
import java.util.Arrays;
importjava.util.Scanner;
public class DemoSort {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个字符串:");
String Str=sc.nextLine();
char []ch=Str.toCharArray();
Arrays.sort(ch);//将字符串转换为字节型数组
String Str1=String.valueOf(ch);//调用String的Valueof()方法,该方法是静态的,因此需要用String类名调用,返回一个String类型
System.out.println("排序后的字符串为:" + Str1);
}
}
三: BigDecimal类
(1) 对于浮点类型的数据类说,他们存储和整数的存储是不一致的,是按照有效数字位来进行存储的,浮点类型的数据计算的时候容易损失精度,计算出来的结果不精确,Java针对这种情况:提供了这个.public BigDecimal(String val);
作用: 作用:来提供浮点类型数据的精确计算!可变的、任意精度的有符号十进制数
(2) publicBigDecimal add(BigDecimal augend):加
* publicBigDecimal subtract(BigDecimal subtrahend):减
* publicBigDecimal multiply(BigDecimal multiplicand):乘法
* publicBigDecimal divide(BigDecimal divisor):除
* publicBigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
# BigDecimal类的运算:
packageBigDecimalDemo_01;
importjava.math.BigDecimal;
public class BigDecimalText_01 {
public static void main(String[] args) {
BigDecimal bd1=new BigDecimal("2.2246");
BigDecimal bd2=new BigDecimal("0.5362");
System.out.println("add:" + bd1.add(bd2));//public BigDecimal add(BigDecimal augend):加
System.out.println("sub:" + bd1.subtract(bd2));//public BigDecimalsubtract(BigDecimal subtrahend):减
System.out.println("mul:" + bd1.multiply(bd2));//public BigDecimalmultiply(BigDecimal multiplicand):乘法
System.out.println("div:" + bd1.divide(bd2));//public BigDecimal divide(BigDecimaldivisor):除
System.out.println("div:" + bd1.divide(bd2, 0, 0));//public BigDecimaldivide(BigDecimal divisor(商),int scale(保留几位小数),int roundingMode(舍入的一种模式:ROUND_HALF_UP))
}
}
四: BigInteger
(1) BigInteger:用来计算超出了Integer类型范围的数据
(2) BigInteger的构造方法: publicBigInteger(String val)将字符串表示的数字封装成BigInteger类型
(3) 成员方法
public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger val)
public BigInteger divide(BigInteger val)
public BigInteger[] divideAndRemainder(BigInteger val) 返回一个BigInteger数组,数组中的元素:商,余数
# BigInteger类的运算:
packageBigIntegerDemo_01;
importjava.math.BigInteger;
public class BigIntegerText_01 {
public static void main(String[] args) {
BigInteger bg1=new BigInteger("520");
BigInteger bg2=new BigInteger("20");
System.out.println("add:" + bg1.add(bg2));//public BigInteger add(BigInteger val):加
System.out.println("sub:" + bg1.subtract(bg2));//public BigIntegersubtract(BigInteger val):减
System.out.println("mul:" + bg1.multiply(bg2));//public BigIntegermultiply(BigInteger val):乘
System.out.println("div:" + bg1.divide(bg2));//public BigInteger divide(BigInteger val):除
System.out.println("div[]:" + bg1.divideAndRemainder(bg2));//public BigInteger[]divideAndRemainder(BigInteger val)返回一个BigInteger数组,数组中的元素:商,余数
}
}
五: Calendar
(1) Calendar该类是一个抽象类:不能实例化的,所以通过一下这个方法来创建对象:
public static Calendar getInstance()例: Calendarcalendar = Calendar.getInstance();
(2) Calendar常用的方法:
public int get(int field)返回给定日历字段的值
public static final int YEAR:表示日历中 的年
public static final int MONTH:月份:是0开始计算的
public static final int DATE:和DAY_OF_MONTH是同义词,表示月份中的某天
public abstract void add(int field,int amount) 为给定的日历的字段添加或者减去时间偏移量
public final void set(int year,int month,int date) 设置日历字段 YEAR、MONTH 和DAY_OF_MONTH 的值
#Calendar类的成员方法综合应用:
packageCalendarDemo_01;
importjava.util.Calendar;
public class CalendarText_02 {
public static void main(String[] args) {
Calendar Cl2=Calendar.getInstance();
Cl2.set(2020, 4, 20);//调用public final void set(intyear, int month, int date)
int year=Cl2.get(Calendar.YEAR);
int month=Cl2.get(Calendar.MONTH);
int date=Cl2.get(Calendar.DAY_OF_MONTH);
System.out.println("当前系统的时间为:" + year + "年" + (month+1) + "月" + date + "号");
System.out.println("-------------");
Cl2.add(Calendar.YEAR, -5);//调用public abstract void add(int field,intamount)方法
year=Cl2.get(Calendar.YEAR);
month=Cl2.get(Calendar.MONTH);
date=Cl2.get(Calendar.DAY_OF_MONTH);
System.out.println("修改后的日期为:" +year + "年" + (month+1) + "月" + date + "号");
}
}
#计算任意一年中二月有多少天:
packageCalendarDemo_01;
importjava.util.Calendar;
importjava.util.Scanner;
public class CalendarText3 {
public static void main(String[] args) {
Scanner Sc=new Scanner(System.in);
System.out.println("请输入任意一个年份:");
int year=Sc.nextInt();
Calendar Cl3=Calendar.getInstance();//创建Calendar的对象
Cl3.set(year, 2, 1);//调用Calendar类的public final void set(intyear, int month, int date)
Cl3.add(Calendar.DAY_OF_MONTH, -1);//调用Calendar类的public abstract void add(int field,intamount)方法
int date=Cl3.get(Calendar.DAY_OF_MONTH);
System.out.println("任意一年的二月有:" + date + "天");
}
}
六:Date类与Calendar类：
（1） 日期类：表示特定的瞬间，精确到毫秒。
（2） 常用的构造方法：
public Date():表示分配的一个Date对象:无参: 通过无参构造获取当前系统的具体的时间
public Date(long date):指定一个时间毫秒值 和它1970-1-1 00:00:00有时间差
（3） Date中的两个成员方法
public long getTime():获取当前时间毫秒值（如果知道Date对象,可以通过getTime()获取时间毫秒值）
public void setTime(long time)
（4） date对象与String类的日期文本格式相互转换
1. 格式化：将Date对象--->String类型的日期的"文本格式"
public final String format(Date date)
2. 解析：String类型日期的"文本格式"---->Date日期对象
public Date parse(String source) 该方法本身会抛出一个异常:ParseException(解析异常:编译时期异常)
#要进行转换:必须使用中间桥梁:DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期Date -> 文本String）、解析（文本String-> 日期Date）和标准化，但是,DateFormat是抽象类,不能直接实例化,使用的是它更具体的子类进行实例化: SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类
注意事项：一定要保证SimpleDateFormat中的String Pattern这个模式和当前给的字符串的文本格式的模式必须一致!
#格式化与解析的综合应用:
packageDateDemo_01;
importjava.text.ParseException;
importjava.text.SimpleDateFormat;
importjava.util.Date;
public class dateText_01 {
public static void main(String[] args) throws ParseException {
//以下是文本格式化操作
Date dt=new Date();
System.out.println("Date类时间为:" + dt);
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
String DateStr=sdf.format(dt);
System.out.println("String类型的时间为:" + DateStr);
System.out.println("----------");
//以下是解析操作
String DateStr1="2020-5-20";
SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd");
Date date1=sdf1.parse(DateStr1);
System.out.println("将文本格式解析之后为:" + date1);
}
}
#计算你一共来到这个世界多少天:
packageCalendarDemo_01;
importjava.text.ParseException;
importjava.text.SimpleDateFormat;
importjava.util.Date;
importjava.util.Scanner;
public class BirthDemo {
public static void main(String[] args) throws ParseException {
Scanner Sc=new Scanner(System.in);
System.out.println("请输入您的出生年月:");
String Str=Sc.nextLine();
SimpleDateFormat Sdf=new SimpleDateFormat("yyyy-MM-dd");//创建SimpleDateFormat对象,并指定与输入的日期模式一样
Date dt1=Sdf.parse(Str);//解析;将String类型字符串转换为Date类型
long time1=dt1.getTime();//调用Date了的get()方法,将出生日期转换为毫秒值
long time2=System.currentTimeMillis();//获取系统当前的毫秒值
long day=(time2-time1)/1000/60/60/24;//计算出天数
System.out.println("您一共在这个世界上生存了:" + day + "天");
}
}
七:Math类：
（1） 常用的数学成员方法：
public static int abs(int a):绝对值
public static double ceil(double a):向上取整
public static double floor(double a):向下取整
public static double max(double a,double b):获取最大值
public static double min(double a,double b):获取最小值
public static double pow(double a,double b):a的b次幂
public static double random():取值范围:[0.0,1.0)
public static long round(double a):四舍五入
public static double sqrt(double a):一个数的正平方跟
（2） 静态导入：JDK5.0以后的新特性
例：import static java.lang.Math.abs;或者import staticjava.lang.Math.*就可以直接用方法名调用静态方法，而不必用ClassName.方法名 的方式来调用。
好处：可以简化一些操作，例如打印操作System.out.println(…);就可以将其写入一个静态方法print(…)，在使用时直接print(…)就可以了。
#Math类方法综合应用:
packageMathDemo_01;
import static java.lang.Math.*;
public class MathDemoText_01 {
public static void main(String[] args) {
System.out.println("求绝对值:" + abs(-12));//调用了Math类的abs()方法,public static int abs(inta):绝对值
System.out.println("对一个数向上取整:" + ceil(12.035));//调用了Math类的public static double ceil(doublea):向上取整
System.out.println( "对一个数向下取整:" + floor(12.360));//调用了Math类的public static double floor(doublea):向下取整
System.out.println("求两个数中的最大值:" + max(9.23,8694));//调用Math类的public static double max(doublea,double b):获取最大值
System.out.println("求两个数中的最小值:" + min(12.06,12.002));//调用Math类的public static double min(doublea,double b):获取最小值
System.out.println("求一个数的幂次方:" + pow(2,3));//调用了Math类的public static double pow(doublea,double b):a的b次幂
System.out.println("产生一个伪随机数: " + random());//调用了Math类的public static double random():取值范围:[0.0,1.0)
System.out.println("对一个数进行四舍五入:" + round(12.536));//调用了Math类的public static long round(doublea):四舍五入
System.out.println("求一个数的算数平方根:" +sqrt(9));//调用了Math类的public static double sqrt(double a):一个数的正平方跟
}
}
八,System类 ：该类没有构造方法,所以字段和成员方法都用静态修饰
（1）in字段：InputStream in = System.in; 标准输入流
（2）out字段：PrintStream(字节打印流) ps =System.out ; 标准输出流
（3）常用的成员方法: public static void gc()运行垃圾回收器。
调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存,最终调用的就是重写之后finalize()回收不用的对象!
(4)publicstatic void exit(int status)终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
(5) public static long currentTimeMillis():返回当前的时间毫秒值
#System类方法综合应用:
packageScannerDemo_01;
importjava.util.Scanner;
public class ScannerText01 {
public static void main(String[] args) {
Scanner Sc=new Scanner(System.in);
System.out.println("请输入一个字符串:");
String Str=Sc.nextLine();
Str=null;
System.gc();
System.out.println("-----------");
Person p=new Person(26,"王抢");
System.out.println(p);
long time=System.currentTimeMillis();//调用System类的public static longcurrentTimeMillis():返回当前的时间毫秒值
System.out.println("系统时间的毫秒值为:" + time);
}
}
class Person{
private int age;
private String name;
public Person(int age, String name) {
this.age = age;
this.name = name;
}
public Person() {
super();
// TODO自动生成的构造函数存根
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person [age=" + age + ",name=" + name + "]";
}
}
(6) publicstatic void arraycopy(Object src,int srcPos,Object dest, int destPos,intlength) 指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束
#arraycopy()方法应用:
packageScannerDemo_01;
importjava.util.Arrays;
public class arraycopyDemo {
public static void main(String[] args) {
int []arra1={23,12,45,22,65,19};
int []arra2={9,4,8,6,7,16,12};
System.arraycopy(arra1, 1, arra2,0, 5);//调用System类的public static void arraycopy(Objectsrc,int srcPos,Object dest, int destPos,intlength)
System.out.println("被复制的数组:" +Arrays.toString(arra1));//被复制过后的数组是一个int型的数组,需要调用Arrays类的toString()方法,最后转换为int型字符串,将其打印出来
System.out.println("复制后的数组:" + Arrays.toString(arra2));
}
}
九:Collection
(1) 集合和数组的区别?
1)长度的区别: 数组:长度是固定的;
集合:长度是可变的
2)存储数据类型的区别: 数组:可以存储引用类型,可以存储基本数据类型
集合:只能存储引用类型
3)存储元素的区别;数组:在同一个数组中,只能存储同一种数据类型的元素;
集合:可以 存储多种数据类型的元素;
#集合是可以存储多种类型的元素,但是,需求如果变化,针对集合来说,Java提供了很多集合类,每一种集合类的数据结构不一样,所以,将他们之间的共性内容抽取出来,就行了一个集合的继承体系图!
(2) Collection: 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现
(3) Collection的一些功能:
添加功能:
boolean add(Object e):给集合中添加指定的元素
boolean addAll(Collection c):添加一个集合中的所有元素
删除功能:
void clear():删除一个集合中的所有元素,暴力删除,(不建议使用)
booleanremove(Object o):删除一个集合中的指定元素
boolean removeAll(Collection c):删除一个集合中的所有元素(删除一个算是删除)
判断功能:
booleancontains(Object o):判断一个集合中是否包含指定的单个元素
booleancontainsAll(Collection c):判断一个集合中是否包含另一个集合; (包含所有算是包含)
boolean isEmpty():判断集合是否为空,如果为空,则返回true
交集功能:
booleanretainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?
答: A集合对B集合取交集,那么交集的元素去A集合里面了,并且返回值boolean表达的意识是A集合中的元素是否发生变化,如果发生变化,就返回true;否则,false;
获取功能:
intsize():获取集合中的元素数
Iterator<E>iterator():迭代器
转换功能:
Object toArray():将集合转换成数组
#数组中有没有length(),String类中有没有length(),集合中有没有length()?
数组中只有length属性,String类中有length()方法,集合中既没有length属性,也没有length()方法,只有size()方法.
#Collection方法的综合应用:
packageCollectionDemo_01;
importjava.util.ArrayList;
importjava.util.Collection;
public class CollectionText01 {
public static void main(String[] args) {
Collection Cl=new ArrayList();
boolean flag1=Cl.isEmpty();//boolean isEmpty():判断集合是否为空,如果为空,则返回true
System.out.println("判断该集合是否为空:" + flag1);
Cl.add("hello");
Cl.clear();//将该集合中的所有元素全部删除
System.out.println("该集合被删除后:" + Cl);
Cl.add("you");
Cl.add("are");
Cl.add("beautiful!");
System.out.println("判断一个集合中是否包含另一个集合的内容:" + Cl.contains("you"));//调用boolean contains(Object o):
System.out.println("求该集合的长度:" + Cl.size());//调用该集合的Size()方法
}
}
(4) 集合的高级功能:
boolean addAll(Collection c):添加一个集合中的所有元素
boolean removeAll(Collection c):删除一个集合中的所有元素
boolean containsAll(Collection c):判断一个集合中是否另一个集合
boolean retainAll(Collection c): A集合对B集合取交集,那么交集的元素去A集合里面了,并且返回值boolean表达的意识是A集合中的元素是否发生变化,如果发生变化,就返回true;否则,false
#集合高级方法的应用:
package CollectionDemo_01;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionText02 {
publicstatic void main(String[] args) {
CollectionCl1=new ArrayList();
CollectionCl2=new ArrayList();
Cl1.add("you");
Cl1.add("are");
Cl1.add("my");
Cl1.add("sunshine!");
Cl2.add("you");
Cl2.add("are");
Cl2.add("my");
Cl2.add("sunshine!");
Cl2.add("mylove!");
// System.out.println(Cl1.addAll(Cl2));
//
// System.out.println(Cl1.containsAll(Cl2));//调用boolean containsAll(Collection c):判断一个集合中是否包含另一个集合; (包含所有算是包含)
//
// System.out.println(Cl1.removeAll(Cl2));//调用boolean removeAll(Collection c):删除一个集合中的所有元素(删除一个算是删除)
System.out.println(Cl2.retainAll(Cl1));//调用boolean retainAll(Collection c):A集合对B集合取交集,那么交集的元素去A集合里面了,并且返回值boolean表达的意识是A集合中的元素是否发生变化,如果发生变化,就返回true;否则,false
System.out.println(Cl1);
System.out.println(Cl2);
}
}
(5) Object[] objs = c.toArray() ;该方法将集合转换为数组
#求集合元素中每个元素与其长度应用:
packageCollectionDemo_01;
importjava.util.ArrayList;
importjava.util.Collection;
public class CollectionText03 {
public static void main(String[] args) {
Collection Cl1=new ArrayList();
Cl1.add("you");
Cl1.add("are");
Cl1.add("my");
Cl1.add("sunshine!");
Cl1.add("my");
Cl1.add("life");
Cl1.add("is");
Cl1.add("brillant!");
Object []obj=Cl1.toArray();//将集合转换为数组
for(int i=0;i<obj.length;i++){//遍历该集合,求出该集合中每个元素,并输出每个元素的长度
System.out.println(obj[i] + "-----------" + ((String) obj[i]).length());//实际进行了向下转型String Str=(String)obj[i]
}
}
}
#有5个学生,每一个学生有自己的信息(姓名,年龄等等),将5个学生的信息遍历出来!
使用集合的转换功能去遍历学生信息
packageCollectionDemo_01;
importjava.util.ArrayList;
importjava.util.Collection;
public class CollectionStudentDemo01 {
public static void main(String[] args) {
Collection Cl1=new ArrayList();
Student s1=new Student(50,"王抢");
Student s2=new Student(32,"上官万成");
Student s3=new Student(21,"欧阳");
Student s4=new Student(33,"黄埔");
Student s5=new Student(22,"张三");
Cl1.add(s1);
Cl1.add(s2);
Cl1.add(s3);
Cl1.add(s4);
Cl1.add(s5);
Object []obj=Cl1.toArray();//将集合转换为数组
System.out.println("学生的信息如下:");
for(int i=0;i<obj.length;i++){
// System.out.println(obj[i]);
Student s=(Student)obj[i];
System.out.println(s.getName()+ "的年龄为:" + s.getAge());
}
}
}
class Student{
private int age;
private String name;
public Student() {
super();
// TODO自动生成的构造函数存根
}
public Student(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
}
十, 迭代器
(1) 成员方法: Object next()返回迭代的下一个元素:获取功能
boolean hasNext():判断一个集合中是否有下一个可以迭代的元素:判断功能
#使用迭代器对集合进行遍历:
packageIteratorDemo_01;
importjava.util.ArrayList;
importjava.util.Collection;
importjava.util.Iterator;
public class IteratorText01 {
public static void main(String[] args) {
Collection Cl1=new ArrayList();
Student s1=new Student(16,"张三");
Student s2=new Student(21,"李四");
Student s3=new Student(23,"王五");
Student s4=new Student(26,"黄六");
Cl1.add(s1);
Cl1.add(s2);
Cl1.add(s3);
Cl1.add(s4);
Iterator it=Cl1.iterator();//创建iterator对象
System.out.println("以下是将Student的基本信息:");
while(it.hasNext()){//调用iterator的hasnext()方法,判断是否有下一个遍历对象;同时iterator的next()方法不能使用多次,否则会出现异常
Student s=(Student)it.next();//因为iterator的next()方法返回Object类型,所以需要使用向下转型,将父类的引用强制转化为子类的引用
System.out.println(s.getName() + "---" + s.getAge());//使用子类的对象调用get()方法
}
}
}
class Student{
private int age;
private String name;
public Student() {
super();
// TODO自动生成的构造函数存根
}
public Student(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
(2) 对象数组:
#对象数组应用:
packageIteratorDemo_01;
public class DUIDemo {
public static void main(String[] args) {
Person[] p=new Person[4];//创建对象数组,并初始化,指定对象数组的长度
Person p1=new Person(18,"貂蝉");//创建Person的对象,并传入参数,进行赋值
Person p2=new Person(20,"西施");
Person p3=new Person(22,"杨贵妃");
Person p4=new Person(20,"王昭君");
p[0]=p1;//将对象的信息分别赋值给对象数组
p[1]=p2;
p[2]=p3;
p[3]=p4;
System.out.println("美女信息如下:");
for(int i=0;i<p.length;i++){
System.out.println(p[i].getName() + "---" + p[i].getAge());//通过Person类对象调用其getname()方法和getage()方法
}
}
}
class Person{
private int age;
private String name;
public Person() {
super();
// TODO自动生成的构造函数存根
}
public Person(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
十一: List集合:
(1)是一个有序的集合(存储元素和取出元素是一致的!)该集合中的元素是可以重复的.
#list集合的迭代器遍历该集合中的一个元素:
packageListDemo_01;
importjava.util.ArrayList;
importjava.util.Iterator;
importjava.util.List;
public class ListText01 {
public static void main(String[] args) {
List li=new ArrayList();//创建list对象
li.add("you");
li.add("are");
li.add("my");
li.add("sunshine!");
li.add("my");//list该集合中的元素是可以重复的.
Iterator it=li.iterator();
System.out.println("遍历后的结果为:");
while(it.hasNext()){//先判断是否有下一个遍历的对象
System.out.print( it.next()+ " ");//接着遍历该集合中的每一个元素
}
}
}
(2)List集合的特有功能:
添加功能: void add(int index, Object element)在列表的指定位置插入指定元素
删除功能: Object remove(int index)移除列表中指定位置的元素,返回被删除的元素
获取功能: ListIterator listIterator():列表迭代器:List集合的专有遍历方式
Object get(int index)返回列表中指定位置的元素。
替换: set(int index,Object element)用指定元素替换列表中指定位置的元素
#list集合方法应用:
packageListDemo_01;
importjava.util.ArrayList;
importjava.util.List;
public class ListText02 {
public static void main(String[] args) {
List li=new ArrayList();//创建list迭代器的对象
li.add("you");
li.add("are");
li.add("my");
li.add("baby!");
li.add(1, "你");//调用list的void add(int index, Object element)在列表的指定位置插入指定元素
System.out.println("添加元素之后:" + li);
li.remove(1);//调用list的Object remove(int index)移除列表中指定位置的元素,返回被删除的元素
System.out.println("删除指定位置的元素后:" + li);
li.set(3, "sunshine!");//调用list的set(int index,Object element)用指定元素替换列表中指定位置的元素
System.out.println("替换指定位置的元素后:" + li);
}
}
(3) List集合的列表迭代器:
ListIterator listIterator()列表迭代器接口中有以下几个方法:
booleanhasNext():判断是否有下一个可以迭代的元素(正向遍历)
Objectnext():如果有可以遍历的元素,就获取这个元素
booleanhasPrevious():判断是否有上一个可以迭代的元素(逆向遍历)
Object previous():如果有上一个可以迭代的元素,就获取上一个元素
#:要使用逆向遍历,前提必须有正向遍历存在,直接使用逆向遍历,没有意义!
#list迭代器的正向逆向遍历:
packageListDemo_01;
importjava.util.ArrayList;
import java.util.List;
importjava.util.ListIterator;
public class ListText03 {
public static void main(String[] args) {
List li=new ArrayList();//创建list对象
li.add("my");
li.add("life");
li.add("is");
li.add("brillant!");
System.out.println("list集合迭代器的正向遍历:");
ListIteratorit=li.listIterator();
while(it.hasNext()){
System.out.print(it.next()+ " ");
}
System.out.println(" ");
System.out.println("list集合的逆向遍历:");
while(it.hasPrevious()){
System.out.print(it.previous() + " ");
}
}
}
#描述:使用迭代器去遍历集合,是不能直接集合添加元素!
解决方案: 1)使用列表迭代器遍历集合,使用列表迭代器添加元素
2)使用集合遍历,使用集合添加元素
#遍历集合中的元素:
packageListDemo_01;
importjava.util.ArrayList;
importjava.util.List;
import java.util.ListIterator;
public class ListText04 {
public static void main(String[] args) {
List li=new ArrayList();//创建list对象
li.add("I");
li.add("need");
li.add("you!");
for(int i=0;i<li.size();i++){//通过集合遍历该集合中的元素
String Str=(String) li.get(i);//调用list的
if("I".equals(Str)){
li.add("hello!");//在集合末尾添加
}
}
System.out.println("遍历的结果为:" + li);
// ListIterator it=li.listIterator();//创建列表迭代器
// while(it.hasNext()){//通过list的迭代器进行遍历集合中的元素
// String Str2=(String)it.next();
// if("need".equals(Str2)){
// it.add("hi!");
// }
// }
// System.out.println(it.toString());
}
}
十二:正则表达式:
(1) A:字符
反斜线字符: 用两个\\代表一个反斜线
(2)B:字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围） :当前字母大小均可
(2) C:预定义字符类
. 邮箱里面:如果本身就是.,那么在写正在表达式的时候,\.将当前.转义
数字：[0-9] \d在正则表达式应用的时候:[0-9]--->\\d
单词字符： [a-zA-Z_0-9]:简单一些字符串,单词字符(规则:数字或者字母)
(3) D:边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界 :
hello;world:haha:xixi
(4) E:Greedy数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
#检验一个QQ号是否满足所给条件:
packageregexDemo_01;
importjava.util.Scanner;
public class RegexText {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个qq号:");
String qq=sc.nextLine();
boolean flag=Check(qq);
System.out.println(flag);
}
public static boolean Check(String s){
String regex="[1-9]\\d{4,9}";//定义正则表达式
boolean flag1=s.matches(regex);//public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。
return flag1;
}
}
#检验qq邮箱号是否符合规则:
packageregexDemo_01;
importjava.util.Scanner;
public class RegexText02 {
public static void main(String[] args) {
Scanner Sc=new Scanner(System.in);
System.out.println("请输入一个邮箱号:");
String Email=Sc.nextLine();//用String类型去接收邮箱号
boolean flag=EmailCheck(Email);
System.out.println(flag);
}
public static boolean EmailCheck(String s){
String regsx="[1-9]\\d{8,10}@[a-zA-Z]{2}.[a-zA-Z]{3}";//定义正则表达式
return s.matches(regsx);//调用String的特有方法public boolean matches(String regex)
}
}
#String类的split()方法:
packageregexDemo_01;
public class SpiltText01 {
public static void main(String[] args) {
String Str="my life is brillant!";
String []StrArray=Str.split(" ");//调用String类的public String[] split(String regex)
System.out.println("分割后的数组是:");
for(int i=0;i<StrArray.length;i++){
System.out.print(StrArray[i] + ",");
}
}
}
(5) 关于模式和匹配器的使用:
1.获取模式对象(通过正则规则) 列: Pattern p = Pattern.compile("a*b");
2. 通过模式获取匹配器对象,(将一个字符串类型的数据) 列: Matcher m = p.matcher("aaaaaab") ;
3. 调用Match(匹配器类)中的:public boolean matches():判断当前用户录入的字符串是否和当前的正则规则匹配 例: boolean flag = m.matches() ;
#模式对象与匹配器的综合应用:
packageregexDemo_01;
import java.util.regex.Matcher;
importjava.util.regex.Pattern;
public class PatternText01 {
public static void main(String[] args) {
Pattern p= Pattern.compile("1[578][1-9]{9,}");//创建模式对象,并定义正则表达式;
Matcher m=p.matcher("18291622798");//创建匹配器对象,并传入String类型的参数
boolean flag=m.matches();
System.out.println("将传入的参数与定义的正则表达式进行对比:" + flag);
}
}
#将字符串"91 27 46 38 50"转化为字符串"27 38 46 50 91"应用:
packageregexDemo_01;
importjava.util.Arrays;
public class SpiltText02 {
public static void main(String[] args) {
String Str="26 31 19 65 50 43 29";//定义字符串
String[] StrArray=Str.split(" ");//调用String的Spilt()方法;返回一个String类型的字符串
int [] array=new int[StrArray.length];//将String类型数组转换为int型数组
for(int i=0;i<array.length;i++){
array[i]=Integer.parseInt(StrArray[i]);//调用Integer类的public static intparseInt(String s)方法,将String类型数转换为int型数
}
Arrays.sort(array);//对数组进行排序
StringBuilder sb=new StringBuilder();//创建StringBuilder对象,此对象可以接收任意类型的元素
for(int i=0;i<array.length;i++){
sb.append(array[i]).append(" ");//遍历该int型数组,并将该数组存放在StringBuilder中
}
String result=sb.toString().trim();//将StringBuilder类型转换为String类型,在调用String的trim()方法,去掉两边的空格
System.out.println(result);
}
}