JAVA学习_week4

class A{
    public void show(){
        System.out.println("我是A");
    }
}
class ADemo{
    public void method(A a){
        a.show() ;
    }
}
public class Test1 {
    public static void main(String[] args) {
            ADemo ad =new ADemo();
            A a =new A();
            ad.show(a);
    }
}

2)抽象类

实际参数：实际参数需要该抽象类的具体的子类对象

举例：

abstract  class Person{
    public abstract  void work(); 
}
class PersonDemo{
    public void show(Person p){
        p.work() ;
    }
}
class Worker extends Person{
    @Override
    public void work() {
        System.out.println("我爱我的工作");
    }
}
public class Test2 {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo() ;
        Person p = new Worker() ;
        pd.show(p);
        
    }
}

3）接口类

实际参数：需要传递该接口的子实现类对象

举例：

interface Person{
    void work() ;
}
class PersonDemo{
    public void function(Person p){
        p.work();
    }
}
class Work implements  Person{
    @Override
    public void work() {
        System.out.println("我爱我的工作");
    }
}
public class Test3 {
    public static void main(String[] args) {
        PersonDemo pd  = new PersonDemo() ;
        Person p = new Work() ;
        pd.function(p);
    }
}

2、返回值问题

1）具体类

返回引用类型：返回当前类的具体对象

举例：

class Way{
    public int result(int a ,int b){
        return (a+b);
    }
}
public class Test4{
        public static void main(String[] args){
            Way w =new Way();
            int result = w.result(10,20);
            System.out.println(result);
        }
}

2)抽象类

返回引用类型：返回该抽象类的子类对象

举例：

abstract  class Person{
    public abstract void work();
}
class PersonDemo {
    public Person show(){ 
        return  new Programmer() ;
    }
}
class Programmer extends  Person{
     @Override
     public void work() {
         System.out.println("日日夜夜写代码，容易秃头！！！");
     }
}
    public class ReturnDemo2 {
       public static void main(String[] args) {
       PersonDemo pd = new PersonDemo() ;
       Person person = pd.show(); 
       person.work();
     }
}

3）接口类

返回引用类型：返回的是当前接口的子实现类对象

举例：

interface Mary{
    void mary() ;
}
class MaryDemo{
    public Mary method(){  
    return  new WeddingCompany() ;
    }
}
class WeddingCompany implements Mary{
    @Override
    public void mary() {
        System.out.println("婚庆公司布置婚礼现场!");
    }
}
public class ReturnDemo3 {
    public static void main(String[] args) {
        MaryDemo maryDemo = new MaryDemo() ;
        Mary m = maryDemo.method();
        m.mary();
    }
}

三、内部类

定义：一个类中定义另一个类

格式：

成员内部类：在一个类的成员位置定义的类

局部内部类：在一个类的局部位置定义的类

1、成员内部类

特点：成员内部类的成员方法可以直接访问外部类的成员包括私有外部类的成员方法：要求访问成员内部类的成员方法，必须通过成员内部类的对象来访问

class A{
    private int i =10;
    
    class B{//内部类
        public void show(){//成员方法
            System.out.println(i);
        }
    }
    public void method(){
        B b =new B();
        b.show();
    }
}
public class Test {
    public static void main(String[] args) {
        Outer2 outer2 = new Outer2();
        outer2.method();
    }
}

2、局部内部类

特点：可以直接访问外部类的成员包括私有，和成员内部类一样

class Outer{
    private int x = 100 ;
    public void show(){
        int num = 20 ;
        class Inner{
            public void method(){
                System.out.println(x);
                System.out.println(num) 
            }
        }
        Inner inner = new Inner() ;
        inner.method();
    }
}
public class InnerClassDemo {
    public static void main(String[] args) {
        Outer outer = new Outer() ;
        outer.show();
    }
}

3、匿名内部类

定义：就是没有名字的类

格式：

抽象类或者接口的匿名内部类
new 类名或者是接口名(){  //类:一般都是抽象类 ,具体类也可也,但是不推荐
重写方法() {
      ...
   }
};

举例：

interface Love{
    void show() ;
}
class Outer2{
    public void method(){
    Love l = new Love(){
            @Override
            public void show() {
                System.out.println("show Love");
            }
    } ;
    l.show();
    }
}
public class Test {
    public static void main(String[] args) {
        Outer2 outer2 = new Outer2() ;
        outer2.method();
    }
}

四、Object类的常用功能

1、Object类的常用功能：

public String toString():本身的含义：返回对象的字符串表示形式(直接输出对象的名称,就是地址值) 结果应该是一个简明扼要的表达，容易让人阅读。建议所有子类覆盖此方法

public final Class getClass():使用对象名调用getClass():获取正在运行的类或者接口(字节码文件对象)也称为"Class类对象"

public int hashCode() (了解:哈希算法---提供哈希表) 返回对象的哈希码值 (理解为 "地址值",不是实际意义的地址值)每一个对象的哈希码值不同的

举例：

class Student{ 
    private String name ;
    private int age  ;
    private String gender ;
    public Student() {
    }
    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    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 getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}
public class Test {

    public static void main(String[] args) {
        Student s1 = new Student() ;
        System.out.println(s1);//输出为Student{name='null', age=0, gender='null'}
        Class c1 = s1.getClass() ;
        System.out.println(c1) ;//输出为class com.qf.object_04.Student
        }
}

2、Object类的equals

public boolean equals(Object obj):比较两个对象是否相同

举例：

import java.util.Objects;
class Person {
    private String name ;//姓名
    private int age ; //年龄
    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);

    }
public class Test {
    public static void main(String[] args) {

        Person p = new Person("张三丰",50) ;
        System.out.println(p) ;
        Person p2 = new Person("张三丰",50) ; //具体类对象创建
        System.out.println(p2);
        System.out.println(p==p2) ;
        
        boolean flag = p.equals(p2);
        System.out.println(flag);

        String s1 = "java" ;
        String s2 = "java" ;
        System.out.println(s1.equals(s2));
    }
}

五、String类

1、认识String类

定义：代表字符串,字符串是一个常量,一旦被创建,其值不改变(地址不变,除非重新赋值) ;

常用的String类的构造方法

public String() :空参构造
public String(char[] value):将字符数组构造出字符串
public String(char[] value,int index,int length):将一部分字符数组转换成字符串
public String(byte[] bytes) :将字节数组构造字符串
public String(String original):将一个字符串值存储进去,构造成一个字符串对象

测试：

public class Test {
    public static void main(String[] args) {
        String s = new String();
        System.out.println(s);
        System.out.println("----------------------------------------------") ;
        char[] chs = {'我','爱','我','家'} ; 
        String s2 = new String(chs) ;
        System.out.println("s2:"+s2);
        System.out.println(s2.length());
        System.out.println("----------------------------------------------") ;
        String ss = new String(chs,1,4);
        System.out.println("ss:"+ss);
        System.out.println(ss.length());
        System.out.println("----------------------------------------------");
        byte[] bytes = {97,98,99,100,101} ;
        String s3 = new String(bytes) ;  
        System.out.println("s3:"+s3) ;
        System.out.println(s3.length());
        System.out.println("-----------------------------------------------");
        // public String(String original):
        String s4 = new String("helloworld") ; 
        System.out.println("s4:"+s4) ;
        System.out.println(s4.length());
    }
}

2、String类应用

String类型作为方法形式参数的特点
String类作为引用类型,当成为方法的形式参数,和基本类型的效果一致:
形式参数的改变,不影响实际参数

public class Test {
    public static void main(String[] args) {
        String s = "helloworld" ; 
        System.out.println(s) ;//输出为helloworld
        change(s) ;            //输出为helloworldJava
        System.out.println(s); //输出为helloworld
    }
    public static void change(String s) {
        s = s+"Java" ;
        System.out.println(s);
    }
}

3、String类常用功能以及判断功能

public char charAt(int index):获取指定索引出的字符
public String concat(String str):字符串拼接功能
boolean contains(String s):判断字符串中是否包含指定的某个字符或者某个子字符串(按照第一个字符判断)
public boolean endsWith(String suffix):判断此字符串是否一指定的字符串结尾
public boolean startsWdith(String prefix):判断此字符串是否一指定的字符串开头
public boolean equals(Object anObject):比较是两个字符串的内容是否相同(必须一样)
public boolean equalsIgnoreCase(String anotherString):比较两个字符串内容是否相同,忽略大小写进行比较
public boolean isEmpty():判断字符串是否空(是否为空内容)
int length():获取字符串长度
public int indexOf(int ch):查询字符串中的某个字符第一次出现的索引值

public class Test {
    public static void main(String[] args) {
        String s = "helloworld" ;
        String str = "helloWORLD" ;
        String str1 = null ;//没有对象的,空对象
        String str2 = "" ;  //空字符串,有
        if(str1!=null){
            System.out.println(str1.concat("Java"));
        }else{
            System.out.println("str1对象为null了");
        }

        System.out.println(s.charAt(0));
        System.out.println(s+"5+5"); 
        String s2 = s.concat("java");
        System.out.println(s2);
        System.out.println(s.contains("wor"));
        System.out.println(s.length());
        System.out.println(s.startsWith("h"));
        System.out.println(s.endsWith("java"));
        System.out.println("---------------------------------------------");
        System.out.println(s.equals(str));
        System.out.println(s.equalsIgnoreCase(str));
        System.out.println("----------------------------------------------") ;
        System.out.println(s.indexOf('l'));
        s = "" ;
        System.out.println(s.isEmpty());

    }
}

4、String类的常用的转换功能

public char[] toCharArray():将字符串转换成字符数组
byte[] getBytes() :使用平台默认的字符集(idea:utf-8:一个中文三个字节)
将字符串数据----变成字节数组 (编码)
public String[] split(String regex):使用分割符号---拆分成字符串数组 (分割功能)
public String toLowerCase():将字符串转换成小写
public String toUpperCase():将字符串转换成大写
public static String valueOf(int i) :这个方法参数可以是任意的Java类型:基本类型或者Object
万能方法:将任何类型转换成String

举例：

public class Test {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s = "helloJavaEE" ;
        char[] chars = s.toCharArray();
        for(int x =0 ; x <= chars.length-1 ; x --){
            System.out.print(chars[x]+" ");
        }
        System.out.println();
        byte[] bytes = s.getBytes();
        for(int x = 0 ; x <bytes.length ;x++){
            System.out.print(bytes[x]+" "); 
        }
        System.out.println();
        String s2= "中国" ;
        byte[] bytes2 = s2.getBytes();
        System.out.println(Arrays.toString(bytes2));

        String result = new String(bytes2,"utf-8") ; 
        System.out.println(result);

        String str = "JavaEE-Python-C-C#-Hadoop-Php-GoLang" ;
        String[] strArray = str.split("-");
        for(int x = 0 ; x <strArray.length ; x++){
            System.out.println(strArray[x]);
        }
        System.out.println(s.toLowerCase());
        System.out.println(s.toUpperCase());
        int i = 100 ;
        System.out.println(i); 
        String s1 = String.valueOf(i);
        System.out.println(s1);
    }
}

5、String类的截取功能

public String substring(int beginIndex):从指定位置处开始截取,默认截取到末尾
public String substring(int beginIndex,int endIndex):从指定位置开始截取,到指定位置结束,但是不包括endIndex位置,
endIndex-1的位置(包前不包后)
Java语言中,只要某个成员方法涉及角标问题,而且有开始索引,有最终索引,不包含最终索引值,最终索引-1的位置

举例：

public class Test {
    public static void main(String[] args) {
        String s = "helloworldJavaEE" ;
        System.out.println(s.substring(5));
        System.out.println(s.substring(5,10));
    }
}

六、StringBuffer

1、构造方法

StringBuffer():空参构造:创建一个支持缓冲区对象
StringBuffer(String str):将指定的字符串存储在字符串缓冲区中  (将String---StringBuffer)
这个类的部分功能和String :
int length(): 获取字符串缓冲区的长度
public int capacity():获取字符串缓冲区的容量 默认容量 16个字符,超过这个容量,会自己分配,使用的新的字符串的长度+16

举例：

public class Test {
    public static void main(String[] args) {
        //StringBuffer():空参构造:创建一个支持缓冲区对象
        StringBuffer sb  = new StringBuffer() ;
        System.out.println(sb);
        System.out.println(sb.length());
        System.out.println(sb.capacity());
        String s = "helloworld" ;
        StringBuffer sb2 = new StringBuffer(s) ;
        System.out.println(sb2) ;//"helloworld"
        System.out.println(sb2.length());
        System.out.println(sb2.capacity());
    }
}

2、StringBuffer常用功能

public StringBuffer append(任意类型数据):添加任何类型数据到字符串缓冲区中
返回值字符串缓冲区本身
public StringBuffer insert(int offset,String xx):插入:在指定位置的前面插入一个新的字符序列
public StringBuffer reverse():将字符串缓冲区字符序列反转

举例：

public class Test {
    public static void main(String[] args) {
        String s ="To be or not to be" ;
        String[] strArray = s.split(" ");
        for(int x = 0 ; x < strArray.length; x++){
            String strResult = strArray[x] ;
            StringBuffer sb = new StringBuffer() ;
            sb.append(strResult).reverse();
            System.out.print(sb.toString().concat(" "));
        }
    }
}

七、Integer类

1、认知

说Integer就必须说起基本类型中的四类八种

基本类型	自动装箱引用类型
byte	Byte
short	Short
int	Integer(重点类)
long	Long
float	Float
duoble	Double
char	Character(重点类)
boolean	Boolean

public static final int MAX_VALUE /public static final int MIN_VALUE：int类型的取值范围

public static String toBinaryString(int i) :将整数值传进去,获取它二进制的字符串形式
public static String toOctalString(int i):将整数值传进去,获取它八进制的字符串形式
public static String toHexString(int i) :将整数值传进去,获取它十六进制字符串形式

public class Test {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE);//-2147483648
        System.out.println(Integer.MAX_VALUE);//2147483647

        System.out.println(Integer.toBinaryString(520));
        System.out.println(Integer.toOctalString(520));
        System.out.println(Integer.toHexString(520));
    }
}

2、Integer类的构造方法

public Integer(int value):将int类型----Integer类型
public Integer(String s) throws NumberFormatException :将数字字符串转换成Integer
throws:抛出异常的意思
抛出异常的可能性,当你传入的字符串如果不是数字字符串,jvm解析的时候,将这个异常就信息打印在控制台上

int---->String :Integer.valueOf(int类型的值)
String---->int :Integer.parseInt(数字字符串)

举例：

public class Test {
    public static void main(String[] args) {

        //int---->String
        //方式1：
        int i = 10 ;
        System.out.println(i+"");//"10"
        //方式2:
        Integer ii  = new Integer(i) ;
        //Integer---->String :public String toString()
        String s = ii.toString();
        System.out.println(s) ; //"10"
        //方式3:
        String s2 = Integer.toString(i);
        System.out.println(s2);

        //String --->int
        String str = "100" ;
        //方式1:
        int number = Integer.parseInt(str);
        System.out.println(number); //100
        //方式2:
        Integer integ = new Integer(str) ;
        int number2 = integ.intValue();
        System.out.println(number2) ;
    }
}

3、Character类

定义：char类型包装类类型

1.构造方法：

Character(char value) :将一个char类型的字符值构造成Character类对象

2.常用的成员方法：

判断字符是否为大写字母字符
public static boolean isUpperCase(char ch)
判断字符是否为小写字母字符
public static boolean isLowerCase(char ch)
判断字符是否为数字字符
public static boolean isDigit(char ch)

举例：

public class Test {
    public static void main(String[] args) {
        int bigCount = 0 ; 
        int smallCount = 0 ;
        int numberCount = 0 ;
        Scanner sc = new Scanner(System.in) ;
        System.out.println("请输入一个字符串:");
        String line =sc.nextLine() ;
        char[] chs = line.toCharArray();
        for(int x = 0 ; x < chs.length ; x++){
            char ch = chs[x] ;
            if(Character.isUpperCase(ch)){
                bigCount++ ;
            }else if(Character.isLowerCase(ch)){
                smallCount ++;
            }else if(Character.isDigit(ch)){
                numberCount++;
            }else{
                System.out.println("没有该字符");
            }
        }
        System.out.println("大写字母字符共有:"+bigCount+"个");
        System.out.println("小写字母字符共有:"+smallCount+"个");
        System.out.println("数字字符共有:"+numberCount+"个");
    }
}

八、Date

定义：java.util.Date:Date表示特定的时间

构造方法：

public Date():无参构造方法 :创建日期对象,获取当前系统时间的日期格式
:包含星期年份月份月中的日期... (获取当前日期:使用这个)
public Date(long date):创建日期对象,和1970年1月1日时间有关系

public SimpleDateFormat(String pattern)
yyyy:年 MM:月 dd:月中日期 HH:小时 mm:分钟 ss:秒

成员方法：

public long getTime():获取时间的毫秒值；

Date---->String public String foramt(Date date) :格式化
   String--->Date: public Date parse(String dateStr) throws ParseException: 解析
   这个本身可能出现异常,如果解析的字符串的格式和 pattern参数的模式匹配,就出错了,解析失败!
   public SimpleDateFormat(String pattern)

public class Test {
    public static void main(String[] args) throws ParseException {

        Scanner sc = new Scanner(System.in) ;
        System.out.println("请输入您的出生年月日:") ;
        String birthDay = sc.nextLine() ; 
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;
        Date birthdayDate = sdf.parse(birthDay);
        Date date = new Date() ;
        long start  = birthdayDate.getTime() ;
        long end = date.getTime() ;
        long time = end -start ;
        long day = time/1000/60/60/24 ;
        long age =day/365;
        System.out.println("您来的这个是有"+day+"天了,你已经"+age+"岁了");


    }
}

九、Random

java.util.Random:随机数生成器

构造方法：

Random() 创建对象之后,调用nextInt()/nextInt(int n):每次随机数数字不一样的

public Random(long seed) :调用nextInt()/nextInt(int n):每次随机数数字一样的

成员方法：

int nextInt():int类型的范围获取
int nextInt(int n):[0,n) :范围

public class Test {
    public static void main(String[] args) {
        Random random = new Random() ;
        int i = random.nextInt(100) +1;
        System.out.println(i);
    }
}

十、System类

1、类的一些常用功能

public static void exit(int status) :参数为0,退出Jvm(正常终止),如果参数不为0,属于异常终止;
public static long currentTimeMillis():获取当前系统时间毫秒值

public static void arraycopy(Object src, 数据源(举例:原数组)
                      int srcPos, 原数组中某个位置
                  Object dest, 目的数据(目标数组)
                      int destPos, 目标数组的某个位置
                      int length 复制的长度
                     ) :复制数组的一部分内容

十一、Collection类

1、定义

Collection<E></>父接口代表所有的单列集合,只能存储一种引用类型的集合
两个子接口 List<E>/Set<E>
ArrayList:经常默认使用的集合(效率高)

基本功能：

boolean add(E e):添加任何类型元素 E---->理解为Object类型元素
boolean contains(Object o):判断集合中是否包含指定的元素
boolean isEmpty():判断集合是否为空
boolean remove(Object o):移出集合中的元素
void clear() :清空集合
int size():获取集合的元素数

Collection高级功能:

Object[] toArray() :将集合转换成对象数组
Iterator iterator() :Collection的专有遍历方式 (迭代器!)

举例：

public class Test {
    public static void main(String[] args) {
        Collection c = new ArrayList() ;
        System.out.println(c.isEmpty());
        System.out.println(c) ;
        c.add("hello") ;
        c.add(100) ; 
        c.add('a') ;
        c.add("world") ;
        System.out.println(c);
        System.out.println(c.contains("hello"));
        System.out.println(c.contains("b"));
        System.out.println(c.size());

    }
}

2、迭代器

Iterator<E> iterator()：迭代器

Iterator:
Object next()返回迭代中的下一个元素。 (返回任意java类型)
boolean hasNext():判断功能:判断迭代器中是否下一个元素
返回true,表示存在
返回false,不存在!

示例：

class Student {
    private String name;
    private int age;
    private String sex;

    public Student() {
    }

    public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        Collection c =new ArrayList();
        Student s1 =new Student("小一",10,"男");
        Student s2 =new Student("小二",10,"女");
        Student s3 =new Student("小三",10,"女");
        Student s4 =new Student("小四",10,"男");
        //Student s5 =new Student("小五",10,"男");
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(new Student("小五",10,"男"));
        Iterator iterator = c.iterator();
        while (iterator.hasNext()){
            Object o = iterator.next();
            System.out.println(o);
        }
    }
}

十二、List集合

1、集合特点

1)元素可以重复
2)存储和取出一致(有序性)

2、便利方式

1)普通for循环: 使用集合 int size():获取元素数
E get(int index):通过角标获取元素
2)集合的列表迭代器ListIterator listiterator()
        ListIterator:
                        boolean hasNext()：是否有下一个元素
                        E next():获取下一个元素

举例：

public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>() ;
        list.add("hello") ;
        list.add("world") ;
        list.add("javaEE") ;
        list.add("易烊千玺") ;
        Object[] objects = list.toArray();
        for(int x  = 0 ;x <objects.length ;x++){
            String s = (String) objects[x];
            System.out.println(s);
        }
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }
        for(int x= 0 ;x < list.size();x++){
            String s = list.get(x);
            System.out.println(s);
        }
        ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()){
            String s = lit.next();
            System.out.println(s) ;
        }
        while(lit.hasPrevious()){
            String s = lit.previous();
            System.out.println(s);
        }
        for(String s:list){
            System.out.println(s);
        }
    }
}

十三、选择排序

1、定义

选择排序：即用数组的第一个元素与第二个第三个依次比较，直到与最后一个对比结束，将最小的数往前面放，然后是第二个元素和后面的元素进行对比，一直要对比数组长度次

示例：

public class Test {
    public static void main(String[] args) {

        //创建一个数组,静态初始化
        int[] arr = {24,69,87,56,13} ;
        for(int x = 0 ; x < arr.length-1; x++){
            for(int y = x+1; y < arr.length ; y++){
                //元素比较,要进行判断,前面的元素和后面元素比较
                if(arr[x] > arr[y]){
                    int temp = arr[x] ;
                    arr[x]  = arr[y] ;
                    arr[y] = temp ;
                }
            }

        }
        System.out.println("排序后:") ;
        System.out.println(Arrays.toString(arr));
    }
}

十四、Vector集合

1、定义

Vector集合底层数据结构数组,是List集合接口子实现类之一,遍历元素能够List的五种方式

2、特有功能

添加元素
public void addElement(E obj):添加任意元素如果E类型确定了,就只能添加这个数据类型
                                                类似于集合的通用功能add(E obj)
遍历元素方式1
public Enumeration<E> elements():获取组件(返回值是枚举接口---产生一系列元素)
                                                        类似于Collection集合的Iterator iterator()迭代器
Enumeration枚举接口
boolean hasMoreElements() 判断是有更多的元素
--->类似于Iterator迭代器里面的hasNext()
E nextElement() :获取下个元素
     --->类似于Iterator迭代器里面的next():获取下一个元素
遍历元素方式2
public E elementAt(int index)通过角标获取元素 ---类似于List集合的public E get(int index)
结合 int size()获取集合长度(集合元素数量)

public class Test {
    public static void main(String[] args) {
        Vector<String> v = new Vector<>() ;
        v.addElement("hello");
        v.addElement("world");
        v.addElement("JavaEE");
        v.addElement("蔡徐坤");

        Enumeration<String> enumeration = v.elements();
        while(enumeration.hasMoreElements()){ 
            String s = enumeration.nextElement();
            System.out.println(s);
        }
        for(int x = 0 ; x < v.size(); x++){
            String s = v.elementAt(x);
            System.out.println(s);
        }

        for(String s:v){
            System.out.println(s);
        }
    }
}

十五、LinkedList集合

1、定义

底层数据结构是一种链表,链表的特点:查询慢(每次需要冲链表头查询到末尾),增删快;

2、特有功能

public void addFirst(E e):添加到链表的开头
public void addLast(E e):添加到链表的末尾
public E getFirst():获取链表的第一个元素
public E getLast():获取链表的末尾的元素
public E removeFirst():删除链表第一个元素
public E removeLast():删除链表的最后一个元素
public void push(E e):推送到链表开头(压栈)---等价于public void addFirst(E e):添加到链表的开头
public E pop():弹出最后一个元素(弹栈) 等于removeFirst() :将第一个元素删除并返回

public class Test {
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<>() ;
        link.addFirst("hello") ;
        link.addFirst("world") ;
        link.addFirst("java") ;
        link.addLast("javaEE");
        System.out.println(link) ;
        String first = link.getFirst();
        System.out.println(first) ;
        String last = link.getLast();
        System.out.println(last);
        System.out.println(link.removeFirst());
        System.out.println(link);

    }
}

十六、Set集合

1、特点

保证元素唯一,而且不能保证迭代次序唯一,无序性(元素不重复,不能保证顺序---哈希表(key-value键值对)完成的(桶状结构))

创建HashSet(Set接口的子实现类之一)集合对象来存储String类型,重复的数据,看效果为什么保证元素能唯一的:
HashSet底层依赖于Map<K,V>接口的子实现类HashMap<K,V>实现的
HashSet的add()方法依赖于HashMap的put 方法,这个方法间接依赖于Object类的equals和hashCode()
而现在存储String类型,String底层已经重写了hashCode()和equals方法
HashCode:比较字符串的哈希码值(理解为地址值)是否一样,如果一样,比较内容是否一样
英文可以,但是中文,繁写字体或简写字体,hashCode一样,内容可能不一样;必须重写equals,比较内容是否相容!

public class Test {

    public static void main(String[] args) {
        Set<String> set = new HashSet<>() ;
        set.add("hello") ;
        set.add("hello") ;
        set.add("javaEE") ;
        set.add("world") ;
        set.add("world") ;
        set.add("android") ;
        set.add("android") ;
        set.add("python") ;
        set.add("python") ;
        for(String s:set){
            System.out.println(s) ;
        }
    }
}

举例：自定义参数去重

public class Test {
    public static void main(String[] args) {
        Set<Person> sp =new HashSet<>();
        sp.add(new Person("张大",18,"男"));
        sp.add(new Person("张二",17,"女"));
        sp.add(new Person("张三",16,"男"));
        sp.add(new Person("张三",16,"男"));
        sp.add(new Person("张四",15,"女"));
        sp.add(new Person("张四",15,"女"));
        sp.add(new Person("张五",14,"男"));
        sp.add(new Person("张五",14,"男"));

        for (Person p:sp){
            System.out.println(p.getName()+"---"+p.getAge()+"---"+p.getSex());
        }
    }
}

十七、总结问题

1、==和equals的区别

==:
基本类型:比较的是数据值是否相同
引用类型:比较的是地址值是否相同
equals():Object类的方法
public boolean equals(Object obj) {
return (this == obj); //this--->就是p obj---->向上转型 p2 ==:比较是两个对象地址值
}
本身默认比较的是两个对象的地址值是否相同;当多个对象的成员信息是相同,认为是同一个人,所以
Object类需要建议所有的子类要重写equals(),比较的是对象的成员信息是否相同!