一.常用类

1.Math(属于lang包中)

1Math 类提供了一序列基本数学运算和几何函数的方法。

2Math类是final类(不能继承),并且它的所有成员变量和成员方法都是静态的(可以用类名直接调用)。

3Math类中常用方法:

*静态常量:Math.PI(圆周率)

*静态方法:

·double pow (double a, double b):计算ab次方

·double sqrt  (double a) :计算给定值的平方根

·double abs(double a):计算a的绝对值

·double ceil (double a):返回大于等于 a的最小整数的double值(向上取整)

·double floor (double a) :返回小于等于 a的最大整数的double值(向下取整)

·int max(int a, int b) a,b中最大值

·int min(int a,int b):a,b中最小值

·int round(float a)a的的四舍五入值

·double random():取一个0(包含)到1(不包含)的伪随机数

·double cbrt(double a):a的立方根

·double log10(double a):a以十为低的对数

例(以上面方法举例):

package commom;

 

import java.util.Scanner;

 

public class MathDemo {

public static void main(String[] args) {

System.out.println("所求4的5次方是:"+Math.pow(4, 5));

System.out.println("输入数向上取整得:"+Math.ceil(9.9));

System.out.println("输入数的绝对值是:"+Math.abs(-56.0));

System.out.println("输入数的立方根是:"+Math.cbrt(8));

System.out.println("输入数向下取整得:"+Math.floor(9.9));

System.out.println("输入数的平方根是:"+Math.sqrt(9));

System.out.println("输入数以十为底的对数是:"+Math.log10(68));

System.out.println("输入数中的最大值:"+Math.max(23, 45));

System.out.println("输入数中 的最小值:"+Math.min(23, 54));

System.out.println("得到一个0(包含)到1(不包含)的浮点数:"+Math.random());

int y=(int)(Math.random()*16)+3;

System.out.println("得到一个3(包含)到18(包含)的随机整数:"+y);

System.out.println("输入数的四舍五入的结果是:"+Math.round(78.499));

System.out.println("输入数的四舍五入的结果是:"+Math.round(67.50111));

Scanner scan=new Scanner(System.in);

System.out.print("请输入圆的半径:");

int r=scan.nextInt();

System.out.println("所输入半径的圆的面积是:"+Math.PI*Math.pow(r, 2));

System.out.println("所输入半径的圆的周长是:"+Math.PI*r*2);

scan.close();

}

}

运行结果为:

所求4的5次方是:1024.0

输入数向上取整得:10.0

输入数的绝对值是:56.0

输入数的立方根是:2.0

输入数向下取整得:9.0

输入数的平方根是:3.0

输入数以十为底的对数是:1.8325089127062364

输入数中的最大值:45

输入数中 的最小值:23

得到一个0(包含)到1(不包含)的浮点数:0.9779898472549314

得到一个3(包含)到18(包含)的随机整数:17

输入数的四舍五入的结果是:78

输入数的四舍五入的结果是:68

请输入圆的半径:12

所输入半径的圆的面积是:452.3893421169302

所输入半径的圆的周长是:75.39822368615503

*注意(绿色标记部分)

2.Random类(util):

 (1)Random类的对象可以生成“伪随机数”。

 (2)常用方法:

  *public int nextInt(int   bound)

   返回从0(包含)bound(不包含)的一个“伪随机”   整数值。

  *public boolean nextBoolean()

   返回一个“伪随机”的boolean

例(以上述为例):

package commom;

 

import java.util.Random;

 

public class RandomDemo {

public static void main(String[] args) {

Random ran=new Random();

double x=ran.nextDouble();

int y=ran.nextInt(10)+3;

System.out.println("输出0(包含)到1(不包含)的浮点型随机数:"+x);

System.out.println("输出3(包含)到12(包含)的随机数:"+y);

System.out.println("输出随机布尔型:"+ran.nextBoolean());

}

}

结果为:

输出0(包含)到1(不包含)的浮点型随机数:0.18420773180887395

输出3(包含)到12(包含)的随机数:7

输出随机布尔型:false

3.System类:

1)成员变量

System类内部包含inouterr三个成员变量,分别代表标准输入流(键盘输入),标准输出流(显示器)和标准错误输出流(显示器)

  1. 成员方法

    *数组拷贝:void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

    例(以上述成员方法与 成员变量为例):

    package commom;

     

    public class SystemDemo {

     

    public static void main(String[] args) {

    System.out.println("正常输出~~");

    System.err.println("错误输出~~");

    System.out.println("数组 复制得:");

    int[] a={1,32,4,5,5,6,2,3,3};

    int[] b={12,34,5,4,6,6,87,4,34};

    System.arraycopy(a, 2, b, 3, 4);

    for(int x:b){

    System.out.print(x+"  ");

    }

    }

    }

    结果为:

    错误输出~~

    正常输出~~

    数组 复制得:

    12  34  5  4  5  5  6  4  34  

     

    3exit()方法

    public static void exit(int status)

    该方法的作用是退出程序。其中status的值为0代表正常退出,非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。

    4gc()方法

    public static void gc()

    该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收,则取决于系统中垃圾回收算法的实现以及系统执行时的情况。

    垃圾回收时,会先调用finalize()方法,释放非java资源

    例(以exit()方法与gc()方法为例):

    SumNumber类:

    package commom;

     

    public class SumNumber {

    @Override

    protected void finalize() throws Throwable {

    int x=5;

    int y=7;

    System.out.print("垃圾回收前进行的计算:积是   "+(x*y));

    }

    }

    测试Finalize类:

    package commom;

     

    public class FinalizeDemo {

     

    public static void main(String[] args){

    SumNumber sum=new SumNumber();

    sum=null;

    System.gc();

    while(true){

    int i=1;

    i++;

    System.out.println(i);

    System.gc();

    System.exit(0);

    }

    }

    }

    结果为:

    测试exit(0)方法2

    垃圾回收前进行的计算:积是   35

    分析:有结果可知在垃圾回收前运行了finalize方法中的内容,主方法中的while本是死循环因为System.exit(0)停止了虚拟机的运行导致while运行了一次就结束了

    *补充(计算时间方法):

    currentTimeMillis方法

    public static long currentTimeMillis()

    以毫秒为单位返回从197011日午夜到当前时间的毫秒数

    例(currentTimeMillis方法):

    package commom;

     

    import java.util.*;

     

    public class CurrentTimeMillsDemo {

    public static void main(String[] args) {

    long startTime=System.currentTimeMillis();

    ArrayList<String> list=new ArrayList<String>();

    Collections.addAll(list, "中国","美国","法国","英国","意大利");

    System.out.println("遍厉list集合为:");

    for(String str:list){

    System.out.print(str+"  ");

    }

    System.out.println();

    long endTime=System.currentTimeMillis();

    System.out.println("遍厉集合所用时间"+(endTime-startTime)+"毫秒");

    }

     

    }

    运行结果为:

    遍厉list集合为:

    中国  美国  法国  英国  意大利  

    遍厉集合所用时间2毫秒

  2. Runtime类:

    1)作用:使应用程序与其运行的环境相关联

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

    3)常用方法:

    *exec(String command)在单独的进程中执行指定的字符串命令,该方法   Process对象,使用Process对象的destroy()方法可以杀掉进程

    *totalMemory()当前虚拟机的总内存(取决于系统运行环境)

    *maxMemory()JVM试图使用的最大内存(最大潜力)

    *freeMemory()当前JVM的空闲内存

    例(以上述方法为例):

    package commom;

     

    import java.io.IOException;

    import java.util.Scanner;

     

    public class RuntimeDemo {

    public static void main(String[] args) {

    Runtime run=Runtime.getRuntime();

    run.gc();//显式请求垃圾回收

    System.out.println("当前JVM的空闲内存:"+run.freeMemory()+"字节");

    System.out.println("当前JVM试图使用的最大内存:"+run.maxMemory()+"字节");

    System.out.println("当前 JVM的总内存(取决于系统环境):"+run.totalMemory()+" 字节");

    try {

    run.exec("notepad");

    run.exec("calc");

    Process hanoi=run.exec("C:\\Users\\Administrator\\Desktop\\XHZ for Hanoi");

    Scanner scan=new Scanner(System.in);

    System.out.print("请输入是否关闭汉罗塔:y/n:");

    String chioce=scan.next();

    if("y".equals(chioce)){

    hanoi.destroy();

    }

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

     

    }

    运行结果:

    当前JVM的内存总量是:56623104字节

    JVM试图使用的最大内存量:827850752

    当前JVM的空闲内存量:55496872

    请输入是否关闭汉罗塔:y/n:y

    5.Dateutil包)类与SimpleDateFormat(text)类:

    1Date类:表示时间与日期,提供当前具体时间,提供操作日期和时间各组成部分的方法

    2SimpleDateFormat类:用于定制时间日期格式

    例(以当前时间为例):

    package commom;

     

    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 stf=new SimpleDateFormat("yyyy-mm-dd  hh:mm:ss.SSS");

    System.out.println("当前日历是:");

    System.out.println(stf.format(date));

     

    }

     

    }

    运行结果为:

    Tue Jan 02 15:18:57 GMT+08:00 2018

    当前日历是:

    2018-18-02  03:18:57.397

    6.Calender类(util包中,为抽象类):

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

    2Calendar类提供一些方法和静态字段来操作日历

    *int get(int field)返回日历中给定字段的值

    *int set()可以用于调整日历

    *MONTH指示月

    *DAY_OF_MONTH当前月中的哪一天

    *WEEK_OF_MONTH当前月中哪一周

    *DAY_OF_YEAR当前年的哪一天

    ..........

    诸如上述格式方法多样

    例(上述方法):

    import java.util.Calendar;

     

    public class CalenderDemo {

     

    public static void main(String[] args) {

    Calendar cal=Calendar.getInstance();

    System.out.println("当前日期的月份:"+cal.get(Calendar.MONTH)+1);

    System.out.println("当前月的第多少天:"+cal.get((Calendar.DAY_OF_MONTH)));

    System.out.println("当前星期的第几天:"+cal.get(Calendar.DAY_OF_WEEK));

    System.out.println("当前月的第几周:"+cal.get(Calendar.WEEK_OF_MONTH));

    cal.set(1998, 02,14);

    System.out.println("当前日期的月份:"+cal.get(Calendar.MONTH)+1);

    System.out.println("当前月的第多少天:"+cal.get((Calendar.DAY_OF_MONTH)));

    System.out.println("当前星期的第几"+cal.get(Calendar.DAY_OF_WEEK));

    System.out.println("当前月的第几周:"+cal.get(Calendar.WEEK_OF_MONTH));

    }

     

    }

    运行结果:

    当前日期的月份:01

    当前月的第多少天:2

    当前星期的第几天:3

    当前月的第几周:1

    当前日期的月份:21

    当前月的第多少天:14

    当前星期的第几天:7

    当前月的第几周:2

  3. 正则表达式

    1.正则表达式(regex)是使用字符串来描述、匹配一系列符合某个句法规则的字符串

    2.用途:匹配、切割、替换、获取字符串

    3.正则表达式由一些普通字符和一些元字符组成。

    4.常见元字符

^

匹配输入字符串的起始位置

$

匹配输入字符串的结束位置

\d

匹配一个数字字符,等价于[0~9]

\D

匹配一个非数字字符,等价于[^0~9]

\s

匹配任何空白字符,包括空格,制表符,换页符等符号[\n\t\f\r]

\S

匹配任何非空白字符等价于[^\n\t\f\r]

\w

匹配包括下划线的任何单个字符等价于[A-Za-z0-9]

\W

匹配包括下划线的任何非单个字符等价于[^A-Za-z0-9]

.

匹配除了“\n\r”的任何单个字符

{n}

n是一个非负整数,匹配确定n

{n,}

n是一个非负整数,至少匹配n

{n,m}

m,n均是非负整数,其中n<=m,最少匹配n次,最多匹配m

*

匹配前面子表达式零次或多次(大于等于0次)

?

匹配前面的子表达式零次或一次,也可用于取消贪婪模式

+

匹配前面的子表达式一次货多次

 

*[....]表示:[字符集]

 

  1. \的含义:

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

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

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

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

     

  2. Pattern类与Matcher类:

    1Pattern类与Matcher类都在java.util.regex包    中定义。

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

    3Pattern类的主要方法:

         public static Pattern compile(String regex);

         public Matcher matcher(CharSequence input)

         Matcher类的主要方法:

         public boolean matches();

    (以上述元字符,Pattern类与Matcher类为例):

    7.String类对正则表达式的支持

    1public boolean matches(String regex)

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

     

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

     

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

  4. 补充:

    &正则表达式中的问号?有两种作用:

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

    ·第二种作用:在表示次数的元字符后加上?代表取消默认的贪婪匹配模              式,变为“非贪婪匹配模式”。

     

    1(中国的邮政编码都是6位验证)

    package regexDemo;

     

    import java.util.Scanner;

    import java.util.regex.*;

    public class PostcodeRegex {

    public static void main(String[] args) {

    Scanner scan=new Scanner(System.in);

    System.out.println("请输入邮编:");

    String postcode=scan.next();

    String regex="\\d{6}";

    Pattern pat=Pattern.compile(regex);

    Matcher mat=pat.matcher(postcode);

    if(mat.matches()){   //System类中是否匹配方法

    System.out.println("邮编正确!");

    }else{

    System.out.println("邮编错误!");

    }

    }

     

    }

    运行结果为:

    请输入邮编:

    724407

    邮编正确!

    2(手机号码都是11位,并且第1位都是1

    package regexDemo;

     

    import java.util.Scanner;

    import java.util.regex.*;

     

    public class PhoneNumRegex {

     

    public static void main(String[] args) {

    Scanner scan=new Scanner(System.in);

    System.out.println("请输入手机号码:");

    String phoneNum=scan.next();

    String regex="1\\d{10}";

    Pattern  pat=Pattern.compile(regex);

    Matcher  mat=pat.matcher(phoneNum);

    if(mat.matches()){

    System.out.println("手机号码格式正确!");

    }else{

    System.out.println("手机号码格式错误!");

    }

    }

     

    }

    运行结果为:

    请输入手机号码:

    13467005453

    手机号码格式正确

    3Email验证):

    package regexDemo;

    import java.util.Scanner;

    import java.util.regex.*;

    public class EmailRegex {

    public static void main(String[] args) {

    Scanner scan=new Scanner(System.in);

    System.out.println("请输入email号:");

    String email=scan.next();

    String regex="\\w+@\\w+\\.\\w+\\.?\\w+";

    Pattern pat=Pattern.compile(regex);

    Matcher mat=pat.matcher(email);

    if(mat.matches()){

    System.out.println("email格式正确!");

    }else{

    System.out.println("email格式错误!");

    }

     

    }

     

    }

     

    请输入email号:

    139537423@qq.com

    email格式正确!

    4(替换):

    package regexDemo;

     

    public class ReplaceDemo {

     

    public static void main(String[] args) {

    String str="judf...dgud...uuif...hdjfhf";

    System.out.println(str.replaceAll("\\.+",""));

     

    }

     

    }

    运行结果为:

    Judfdguduuifhdjfhf

    *补充:

  5. find()方法移动指针,group()方法分组

  6. \\1引用前面第一个分组

  7. 在正则表达式中\num代表“反向引用”第num个分组的内容

    5(拆分我爱中华haha123中国万岁haha46456干点啥感觉haha79567";

    中的haha数字分组):

    package regexDemo;

     

    import java.util.regex.*;

     

    public class SpiltDemo {

    public static void main(String[] args) {

    String str="我爱中华haha123中国万岁haha46456干点啥感觉haha79567";

    String regex="(haha\\d+)";

    Pattern pat=Pattern.compile(regex);

    Matcher mat=pat.matcher(str);

    int i=0;

    while(mat.find()){

    i++;

    System.out.println(+i+组为:mat.group(1));

    }

    }

     

    }

    运行结果为:

    1组为:haha123

    2组为:haha46456

    3组为:haha79567

    6在正则表达式中,\num代表“反向引用”第num个分组中的内容

    package regexDemo;

     

    import java.util.regex.*;

     

    public class BackRegex {

     

    public static void main(String[] args) {

    String str="fjkdshahaguidsghthtiusfyuyusfgireregdgtdr";

    String regex="([A-Za-z]{2})\\1";

    Pattern pat=Pattern.compile(regex);

    Matcher mat=pat.matcher(str);

    int i=0;

    while(mat.find()){

    i++;

    System.out.println("第"+i+"组"+mat.group(0));

    }

    }

     

    }

    运行结果为:

    1组haha

    2组htht

    3组yuyu

    4组rere

    7(贪婪模式及非贪婪模式):

    package regexDemo;

     

    public class abbbDemo {

     

    public static void main(String[] args) {

    String str="xyyyyyyyyyyyyyy";

    System.out.println("贪婪模式: "+str.replaceAll("xy+", "*"));

    System.out.println("非贪婪模式: "+str.replaceAll("xy+?", "*"));

    }

     

    }

    运行结果:

    贪婪模式: *

    非贪婪模式: *yyyyyyyyyyyyy

  8. 枚举类型(引用类型中的一类)

    1. 枚举类型使用一组常量值来表示特定的数据集合,该集合中数据的数目确定(通常较少),且这些数据只能取预先定义的值。

    2. Java枚举类型均自动继承java.lang.Enum类(该类继承了Object类)。

    3.声明枚举类型:

    [public] enum 枚举类型名称{

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

    }

     

    eg:  public enum Color{

           RED,GREEN,BLUE;

    }

    4.获取枚举对象的两种方法:

    *方法一:取得单个枚举对象

                    枚举.对象名

     

    *方法二:取得全部枚举对象

                    枚举.values()

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

    (写一个枚举并获取其对象)

    package enumdemo;

     

    public class TsetEnumcountry {

     

    public static void main(String[] args) {

    EnumCountry country=EnumCountry.CHINA;

    EnumCountry country1=EnumCountry.FRANCH;

    System.out.println("枚举EnumCountry中一个元素为:"+country);

    System.out.println("枚举EnumCountry中一个元素为:"+country1);

    for(EnumCountry country2:EnumCountry.values()){

    System.out.println("遍厉枚举中的所有元素为:"+country2+"   ");

    }

     

    }

     

    }

    运行结果为:

    枚举EnumCountry中一个元素为:CHINA

    枚举EnumCountry中一个元素为:FRANCH

    遍厉枚举中的所有元素为:CHINA   

    遍厉枚举中的所有元素为:FRANCH   

    遍厉枚举中的所有元素为:AMERICAN   

    遍厉枚举中的所有元素为:JAPAN

    2(根据id找性别):

    学生枚举:

    package enumdemo;

     

    public enum Student {

    MALE("张三",1),FEMALE("李四",2);

    private String name;

    private int id;

    private Student() {

    }

    public static Student findById(int id){

    for(Student stu:Student.values()){

    if(stu.id==id){

    return stu;

    }

    }

    return null;

    }

    private Student(String name, int id) {

    this.name = name;

    this.id = id;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public int getId() {

    return id;

    }

    public void setId(int id) {

    this.id = id;

    }

     

    }

    测试枚举类:

    package enumdemo;

     

    import java.util.Scanner;

     

    public class TestDemo {

     

    public static void main(String[] args) {

    Scanner scan=new Scanner(System.in);

    System.out.print("请输入id:");

    int id=scan.nextInt();

    Student stu=Student.findById(id);

    System.out.println("根据id找到的性别:"+stu);

     

    }

     

    }

    运行结果为:

    请输入id:1

    根据id找到的性别:MALE

  9. 集合的概念与框架的的结构

  10. 集合与数组的对比:

    *数组:长度固定,遍历速度快可以存储基本类型和引用类型

    *集合:如果并不知道程序运行时会需要多少对象,或者需要

    更复杂方式存储对象——可以使用Java集合框架

  11. 集合的概念:·Java API所提供的一系列类的实例,可以用于动态存放多个      对象。

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

    ·特点:长度不固定,只能存储引用类型对象

  12. 集合的框架:(图一)

    Collecton

     

    List

    Set

     

     

     

     

    ArrayList

    LinkedList

    HashSet

    TreeSet

     

     

     

    Collections

    其中图一中Collection,List,Set都是接口,其他都是集合实现类,Map集合以后学后再说

    *其中Collections类中提供了集合进行拍序,遍厉等各种算法,算是集合的工具类

    1. Collection接口中定义了一些集合的常用方法

    方法

    说明

    int size()

    返回此collection中的元素数

    Boolean isEmpty()

    判断此collection中是否包含元素

    boolean contains(Object obj)

    判断此collection是否包含指定的元素。

     

    boolean add(Object element);

    向此collection中添加元素

    boolean remove(Object element);

    从此collection中移除指定的元素。

    void clear();

    移除些collection中所有的元素。

    Iterator iterator();

    返回在此collection的元素上进行迭代的迭代器

    Object[] toArray();

    把此collection转成数组。

    5.Collection接口-定义了存取对象的方法。两个常用的子接口:

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

    *Set接口:存放的元素不包含重复元素的集合接口。

    本节暂不举例等实现类学习之后举例

    1. List集合及其实现类

    2. List接口是Collection接口的子接口

    3. 实现List接口的集合类中的元素是有序的,且允许重复。

    4. List集合中的元素都对应一个整数型的序号记载其在集合中的位置,可以根据序号存取集合中的元素。

    5. JDK API中常用的List集合类常用的有:

    6. ArrayList集合

    7. LinkedList集合

    8. List集合中的常用方法(List接口比Collection接口中新增的几个实用方法):

      1public Object get(int index);

      返回列表中的元素数

      2public Object add(int index, Object element);

      在列表的指定位置插入指定元素.将当前处于该位置的元素(如果有的话) 和所有后续元素向右移动

      3public Object set(int index, Object element) ;

      用指定元素替换列表中指定位置的元素

      4public Object remove(int index);

      移除列表中指定位置的元素

      5public ListIterator listIterator()

      返回此列表元素的列表迭代器

    9. List接口实现类(ArrayList:

    10. ArrayList是使用数组集合实现List

    11. 优点:对于使用引索取出元素有较好的效率,它使用索引快速定位对象

    12. 缺点:元素做删除或插入速度较慢,因为它使用了数组需要移动后面的元素以调整索引

      例(ArrayList使用):

      package ListDemo;

       

      import java.util.ArrayList;

      import java.util.Scanner;

       

      public class ArrayListDemo {

       

      public static void main(String[] args) {

      Scanner scan=new Scanner(System.in);

      System.out.print("请输入要获取的元素的索引:");

      int  i=scan.nextInt();

      ArrayList<String> list=new ArrayList<>();

      list.add("中国");

      list.add("法国");

      list.add("英国");

      list.add("美国");

      list.add("意大利");

      System.out.println("输入 缩引位置的元素是:"+list.get(1));

      System.out.println("______**____________");

      System.out.println("使用增强for循环遍厉集合中的元素:");

      for(String str:list){

      System.out.print(str+"  ");

      }

      System.out.println();

      System.out.println("_______*******______");

      System.out.println("起始集合的长度:"+list.size());

      list.remove(2);

      System.out.println("现在集合的长度为:"+list.size());

      System.out.println("缩引位置替换后集合遍厉:");

      list.set(2, "China");

      for(String str:list){

      System.out.print(str+"  ");

      }

      System.out.println("________*******_________");

          System.out.println("集合中包含“意大利”吗"+list.contains("意大利"));

          System.out.println("______**for循环遍厉集合**__________");

          for(int j=0;j<=list.size();j++){

           System.out.print(list.get(j)+"  ");

          }

          scan.close();

      }

       

      }

      运行结果为:

      请输入要获取的元素的索引:1

      输入 缩引位置的元素是:法国

      ______**____________

      使用增强for循环遍厉集合中的元素:

      中国  法国  英国  美国  意大利  

      _______*******______

      起始集合的长度:5

      现在集合的长度为:4

      缩引位置替换后集合遍厉:

      中国  法国  China  意大利  

      ________*******_________

      集合中包含“意大利”吗true

      ______**for循环遍厉集合**__________

      中国  法国  China  意大利  

    13. LinkedList实现类:

      1LinkedList是使用双向链表实现的集合。

      2LinkedList新增了一些插入、删除的方法。

      3)优点:频繁的插入或删除元素有较好的效率

      4)缺点:查询元素时,效率低,因为要从第一个元素查找。

      例(LinkedList的使用):

      package ListDemo;

       

      import java.util.LinkedList;

       

      public class LinkedListDemo {

       

      public static void main(String[] args) {

      LinkedList<String> list=new LinkedList<String>();

      list.push("中国");

      list.push("法国");

      list.push("英国");

      list.push("美国");

      System.out.println("模拟栈数据结构:");

      System.out.println(list.remove());

      System.out.println(list.remove());

      System.out.println(list.remove());

      System.out.println(list.remove());

      list.add("中国");

      list.add("法国");

      list.add("英国");

      list.add("美国");System.out.println("模拟队列数据结构:");

      System.out.println(list.pop());

      System.out.println(list.pop());

      System.out.println(list.pop());

      System.out.println(list.pop());

       

      }

       

      }

      运行结果为:

      模拟栈数据结构:

      美国

      英国

      法国

      中国

      模拟队列数据结构:

      中国

      法国

      英国

      美国

      8.Collections类:

      1)工具类,类中都是静态方法,可以用类名直接调用

      2)主要方法:

      *Collections.addAll():添加元素

      *shuffle():打乱元素

      *revese():反转元素

      例(以上述方法为例):

      package collectionsdemo;

       

      import java.util.ArrayList;

      import java.util.Collections;

       

      public class CollectionsDemo {

       

      public static void main(String[] args) {

      ArrayList<String> list=new ArrayList<>();

      Collections.addAll(list, "中国","法国","美国","英国");

      Collections.shuffle(list);

      System.out.println("反转之后集合遍厉:");

      showList(list);

      Collections.reverse(list);

      System.out.println("打乱之后集合遍厉:");

      showList(list);

       

      }

      public static void showList(ArrayList<String> list){

      for(String str:list){

      System.out.print(str+"  ");

      }

      System.out.println();

      }

       

      }

      运行结果为:

      反转之后集合遍厉:

      英国  美国  法国  中国  

      打乱之后集合遍厉:

      中国  法国  美国  英国  

    14. ArrayListLinkedList分别在何时使用:

      1ArrayList:遍历元素和随机访问元素的效率比较高,插入、删除等操作频繁时性能低下

      2LinkedList:插入、删除元素时效率较高,查找、遍历效率较低

      六.迭代器的使用

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

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

      3.所有实现了Collection接口的集合类都有一个iterator()方法用以返回一个实现了Iterator接口的对象。

      Iterator it = coll.iterator();

      while(it.hasNext()){

             it.next();

      }

      4.Iterator接口中定义了如下方法(迭代器的使用方法):

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

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

      游标

       

       

       

       

       

      例(以上述方法为例):

      package iteratordemo;

       

      import java.util.*;

       

      public class IteratorDemo {

       

      public static void main(String[] args) {

      ArrayList<String> list=new ArrayList<>();

      Collections.addAll(list, "中国","法国","英国","美国");

      Iterator<String> iter=list.iterator();

      while(iter.hasNext()){

      System.out.print(iter.next()+"  ");

      }

       

      }

       

      }

      运行结果为:

      中国  法国  英国  美国

      七.Set集合接口实现类

      1.Set接口没有提供Collection接口额外的方法,但实现Set接口的集合类中的元素是不可重复的。

      2.JDK API中所提供的Set集合类常用的有:

      1HashSet:散列存放

      2TreeSet:有序存放

      3LinkedHashSet

      3.HashCode集合实现类:

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

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

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

      4.HashSet的使用技巧及特点

      1HashSet不保存元素的加入顺序。

      2HashSet接口存、取、删对象都有很高的效率。

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

      1HashSet为例):

      package hashsetdemo;

       

      import java.util.HashSet;

       

      public class HashSetDemo {

       

      public static void main(String[] args) {

      HashSet<String> set=new HashSet<>();

      set.add("中国");

      set.add("美国");

      set.add("法国");

      set.add("英国");

      set.add("意大利");

      for(String str:set){

      System.out.print(str+"  ");

      }

      System.out.println();

      }

       

      }

      运行结果为:

      美国  法国  意大利  中国  英国

      由此可见HashSet 集合中并没有保存放入顺序

      2(重写equals方法及HashCode去重):

      Student类:

      package hashsetdemo;

       

      public class Student {

      private String name;

      private int age;

      private String sex;

      public Student() {

      super();

      }

      public Student(String name, int age, String sex) {

      super();

      this.name = name;

      this.age = age;

      this.sex = sex;

      }

       

       

      @Override

      public int hashCode() {

      return  age*2;

      }

      @Override

      public boolean equals(Object obj) {

      if (this == obj){

      return true;

      }else if(obj == null){

      return false;

      }else if(!(obj instanceof Student)){

      return false;

      }

      Student stu=(Student)obj;

      if(this.name!=null && this.name.equals(stu.name) && this.age==stu.age && this.sex.equals(stu.sex)){

      return true;

      }

      return false;

      }

      @Override

      public String toString() {

      return "Student [name=" + name + ", age=" + age + ", sex=" + sex+"]";

       

      }

      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;

      }

      public String getSex() {

      return sex;

      }

      public void setSex(String sex) {

      this.sex = sex;

      }

       

      }

      Student测试类:

      package hashsetdemo;

       

      import java.util.HashSet;

       

      public class TestStudent {

       

      public static void main(String[] args) {

      HashSet<Student> set=new HashSet<Student>();

      set.add(new Student("令狐冲",21,"男"));

      set.add(new Student("令狐冲",21,"男"));

      set.add(new Student("李元芳",22,"男"));

      set.add(new Student("杨过",21,"男"));

      set.add(new Student("令狐冲",21,"男"));

      set.add(new Student("独孤求败",25,"男"));

      set.add(new Student("令狐冲",24,"男"));

      set.add(new Student("张无忌",21,"男"));

      set.add(new Student("小龙女",20,"女"));

      for(Student stu:set){

      System.out.println(stu+"  ");

      }

       

      }

       

      }

      运行结果为:

      Student [name=令狐冲, age=24, sex=男]  

      Student [name=独孤求败, age=25, sex=男]  

      Student [name=小龙女, age=20, sex=女]  

      Student [name=令狐冲, age=21, sex=男]  

      Student [name=杨过, age=21, sex=男]  

      Student [name=张无忌, age=21, sex=男]  

      Student [name=李元芳, age=22, sex=男]  

    15. TreeSet集合实现类:

      (1)TreeSet:可以对加入其中的元素进行排序。但前    提是,必须指定排序规则。

       

      (2)构造方法: public TreeSet()

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

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

        public int compareTo(Girl girl)

               if(this.xxx>girl.xxx){

                         return 1;

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

                         return  -1;

              }else{

                         return 0;

              }

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

      1(以Tree为例):

      package treeset;

       

      import java.util.TreeSet;

       

      public class TreeSetDemo {

       

      public static void main(String[] args) {

      TreeSet<String> set=new TreeSet<>();

      set.add("中国");

      set.add("德国");

      set.add("法国");

      set.add("英国");

      set.add("美国");

      set.add("意大利");

      set.add("俄罗斯");

      for(String str:set){

      System.out.print(str+"  ");

      }

       

      }

       

      }

      运行结果为:

      中国  俄罗斯  德国  意大利  法国  美国  英国  

      TreeSet集合中自有一套自己的排序规则

      2(根据自定义排序):

      学生类:

      package treeset;

       

      public class Student implements Comparable<Student>{

      private String name;

      private int score;//总分

      private int math;//数学分数

      public Student() {

      super();

      }

      @Override

      public String toString() {

      return "Student [name=" + name + ", score=" + score + ", math=" + math

      + "]";

      }

       

      @Override

      public int compareTo(Student stu) {

      if(this.score>stu.score){

      return -1;

      }else if(this.score<stu.score){

      return 1;

      }else if(this.math>stu.math){

      return -1;

      }else if(this.math<stu.math){

      return  1;

      }

      return this.name.compareTo(stu.name);

      }

      public Student(String name, int score, int math) {

      super();

      this.name = name;

      this.score = score;

      this.math = math;

      }

      public String getName() {

      return name;

      }

      public void setName(String name) {

      this.name = name;

      }

      public int getScore() {

      return score;

      }

      public void setScore(int score) {

      this.score = score;

      }

      public int getMath() {

      return math;

      }

      public void setMath(int math) {

      this.math = math;

      }

       

      }

      测试类:

      public class TestStudent {

       

      public static void main(String[] args) {

      TreeSet<Student> set=new TreeSet<>();

      set.add(new Student("王磊",456,78));

      set.add(new Student("王忠磊",564,97));

      set.add(new Student("王磊",456,78));

      set.add(new Student("王磊",456,78));

      set.add(new Student("风清扬",786,123));

      set.add(new Student("杨过",456,98));

      set.add(new Student("令狐冲",556,86));

      set.add(new Student("张无忌",665,100));

      set.add(new Student("独孤求败",786,145));

      set.add(new Student("孙悟空",754,147));

      set.add(new Student("唐僧",453,67));

      for(Student stu:set){

      System.out.println(stu+"  ");

      }

       

      }

       

      }

      运行结果:

      Student [name=独孤求败, score=786, math=145]  

      Student [name=风清扬, score=786, math=123]  

      Student [name=孙悟空, score=754, math=147]  

      Student [name=张无忌, score=665, math=100]  

      Student [name=王忠磊, score=564, math=97]  

      Student [name=令狐冲, score=556, math=86]  

      Student [name=杨过, score=456, math=98]  

      Student [name=王磊, score=456, math=78]  

      Student [name=唐僧, score=453, math=67]

      注意:TreeSet比较排序已经重复元素去重了

       

      补充(泛型):

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

      2.泛型的好处:

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

    16. 泛型类:

      class  Gen<T> {

          private T ob; // 定义泛型成员变量

       

          public Gen(T ob) {

              this.ob = ob;

          }

          public T getOb() {

              return ob;

          }

          public void setOb(T ob) {

              this.ob = ob;

          }

          public void showType() {

              System.out.println("T的实际类型是: " + ob.getClass().getName());

          }

      }

      4.受限泛型

      1)设置上限

            类名称<? extends 上限类>

             只能接收上限类对象或其子类对象

      2)设置下限

           类名称<?  super  下限类>

            接收下限类对象或其父类对象

      注意:若定义泛型类,可以将?设置为泛型标识。

      例:

      泛型接口:

      package generic;

       

      import java.util.List;

       

      public class MyGeneric<T extends List> {

         private T info;

      }

       

      泛型测试类:

      package generic;

       

      import java.util.List;

       

      public class TestGeneric {

       

      public static void main(String[] args) {

      MyGeneric<List> mg=new MyGeneric<List>();

       

      }

       

      }

      测试类:

      package generic;

       

      import java.util.*;

       

      public class GenericDemo {

       

      public static void main(String[] args) {

      ArrayList<String> list=new ArrayList<String>();

              list.add("apple");

              list.add("banana");

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

      }

       

       

       

      }

      运行结果:

      apple  banana  

      【本次总结完毕】