一:二分查找:

(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);

}

}

正则表达式/Calendar/集合/迭代器相关推荐

1. 【Groovy】集合遍历 ( 使用集合的 reverseEach 方法进行遍历 | 倒序集合迭代器 ReverseListIterator 类简介 | 代码示例 )

   文章目录 一.使用集合的 reverseEach 方法进行倒序遍历 二.倒序集合迭代器 ReverseListIterator 类简介 三.代码示例 一.使用集合的 reverseEach 方法进行倒 ...

2. Java集合迭代器原理图解_Java Iterator接口遍历单列集合迭代器原理详解

   这篇文章主要介绍了Java Iterator接口遍历单列集合迭代器原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Iterator接口概述 ...

3. 【Java笔记】---Week06 常用类、正则表达式与集合

   写在前面的部分 本周主要学习了以下几个部分,一个是继续学习了常用类的相关知识,第二个学习了正则表达式,然后简单学习了集合方面的知识,扩充补充了二分查找方面的知识 一.常用类 1.System类 Sys ...

4. Python疯狂讲义（常见模块：sys/os/random/time/json/正则表达式/set集合）

   九.常见模块 1.sys sys模块代表了Python解释器,主要用于获取和Python解释器相关的信息 import sys list_sys = [] for e in dir(sys):if n ...

5. Day 4：集合——迭代器与List接口

   Collection-迭代方法 1.toArray()  返回Object类型数据,接收也需要Object对象! Object[] toArray(); Collection c = new Arra ...

6. java 集合迭代器_Java中的集合迭代器

   集合的迭代器 任何集合都有迭代器. 任何集合类,都必须能以某种方式存取元素,否则这个集合容器就没有任何意义. 迭代器,也是一种模式(也叫迭代器模式).在java中它是一个对象,其目的是遍历并选中其中的 ...

7. java集合迭代器_java集合迭代器

   一.Java中有一个设计模式是迭代器模式 1.迭代器模式定义 迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中的各种元素,而又不暴露该对象的内部表示. 2.迭代器模式概述 Java集 ...

8. -1-3 java集合框架基础 java集合体系结构 Collection 常用java集合框架 如何选择集合 迭代器 泛型 通配符概念 Properties 集合 迭代器...

   集合又称之为容器存储对象的一种方式 •数组虽然也可以存储对象,但长度是固定的:显然需要可变长度的容器 集合和数组的区别?                 A:长度区别                  ...

9. Java Collection集合 --迭代器 -- 泛型 --List接口案例

   案例1 需求:具体要求如下:学生练习 1.定义一个学生类Student,包含三个属性姓名.年龄.性别, 私有成员变量,生成无参,有参构造方法,生成get/set方法并重写toString()方法. 2 ...

10. java集合---迭代器iterator

    一:ArraryList  最终继承超级接口Collection,Colection接口继承Iterator接口. public interface Collection<E> exten ...

最新文章

1. SQL Server数据库镜像部署 错误1418’处理及证书验证
2. Python 基础教程（第2版） 中文版+英文原版下载
3. shell编程学习笔记－－整数自增
4. TensorFlow和ML前5名的课程
5. 第二百四十六节，Bootstrap弹出框和警告框插件
6. 国内最缺的架构实践，DDD领域驱动设计排第一！
7. OSO.EXE病毒专杀工具
8. Nginx 性能调优
9. Qt - 一文理解QThread多线程（万字剖析整理）
10. 全国计算机等级考试 二级C语言考前复习资料（笔试）
11. 如何用视频转换器把qlv格式转换mp4
12. 【May Be DNK】JSON.parse() and JSON.stringify()的两个实用技巧
13. 2021年浙江省跨境电商行业发展概况及发展趋势分析[图]
14. c语言程序常用的数学函数,C语言函数——常用数学函数
15. 「奋斗者协议」又来了：自愿加班、接受淘汰、不与公司发生法律纠纷
16. django-DIL模板自定义过滤器，自定义标签，自定义包含标签
17. Android精品软件汇总（不断更新）
18. Doc2Vec句向量模型PV-DM与PV-DBOW的理解
19. 数码管：3位6脚的数码管分析和编码
20. FRM笔记之金融市场与产品-关于利率

热门文章

1. 玩具积木行业调研报告 - 市场现状分析与发展前景预测
2. 基于车载以太网的音视频传输 AVB vs RTP
3. 创新思维案列分析——苹果公司
4. 计算机软件如何永久删除,【电脑软件教程篇】如何永久彻底清除电脑使用痕迹...
5. MP3编码之shine压缩异常解决
6. PID 详解 （附伪代码
7. matlab 10为底指数,matlab指数函数
8. android连接wifi不能上网,手机已经连接wifi但无法上网的详细解决方法
9. 计算机组装所需硬件,电脑组装机配置清单
10. java学习之高级语法（二十八）----- 网络编程