第五周总结(2022.11.14~2022.11.19)

==和equals()方法区别?
==:比较两个基本类型,数据值是否相等
==:连接是两个引用类型,比较的是地址值是否相等
而Object的equals方法,默认比较的是两个引用类型的地址值是否相等,建议子类需要重写这个equals(),重写之后比较的是
两个对象的成员信息是否相同!(Java中所有类都会重写!) ,重写equals方法,必须同时重写hashCode()方法

重写equals:比较每一个对象的成员信息是否相同如果一样,还要比较每一个成员信息 hashCode()哈希码值是否一样,如果都相同
系统认为这个两个人是一样的!

4.Object的克隆方法

protected Object clone() throws CloneNotSupportedException 创建对象并返回它的"副本"
方法里面本身就会带有CloneNotSupportedException:克隆不支持的异常(当要对某个Object的类进行克隆
如果这个类不能实现cloneable接口,那么就会出现这个异常)

2.Scanner类提供一个判断功能

1.java.util.Scanner:文本扫描器

构造方法:
    public Scanner(InputStream source) 创建键盘录入对象

   创建一个文本扫描器
   Scanner 对象名 = new Scanner(System.in) ;
   --->System类---变量名
   public static final InputStream in
  成员方法:

  nextXXX():获取功能
   public int nextInt() :录入int类型
public String nextLine() ;录入String类型

判断功能:
   public boolean hasNextInt():判断录入的下一个数据是否为int类型,是,返回true,否则false
   public boolean hasNextLine():判断录入的下一个数据为一行内容

   键盘录入的时候
   先录入int,在录入String ----nextLine() ,这块会出现被漏掉("回车符号")
   解决方案:
   1)在第一个录入int之后,重新创建一个新的键盘录入对象Scanner ,然后在使用nextLine()
   2)在录入String---- String next()

3.String以及StringBuffer(字符串缓冲区) (重点)

String类: 这个类final修饰不能被继承
字符串是不变; 它们的值在创建后不能被更改(字符串是一个常量,存储在常量池中)

构造方法:
   public String():空字符串类似于 String s = "" ;
   public String(String original):构造一个字符串对象,里面指定一个字符串常量值
   public String(byte[] bytes) :使用平台默认字符集(idea默认utf-8)解析解码--->字节数组--->字符串
   String(byte[] bytes, int offset, int length) :将一部分字节数组构造成字符串
   public String(char[] value):将字符数组---构造成String
   public String(char[] value,int offseet,int len):将一部分字符串数组构造成字符串

2.面试题:

数组中没有length(),字符串有没有length(),集合中没有有length()?

数组没有length(),length属性数组对象.length
字符串有length(),
集合没有,获取集合中元素数 size()

String s = new String("hello")和String s = "hello" ; 有什么区别?分别创建了几个对象?

区别
前者:在堆内存中开辟空间,然后字符串值常量---指向常量池, 两个对象
后者:推荐的方式,直接常量赋值,直接在常量池中找,有就返回地址,没有,开辟常量空间!

3.String类相关的获取功能

1)public char charAt(int index) :获取指定索引处的字符
2)int length():获取字符串的长度
3)public String concat(String str)拼接功能-- 将一个字符串拼接到指定字符串的后面(末尾追加)
4)public String substring(int beginIndex):截取--->从指定位置开始截取,默认截取到末尾结束!
public String substring(int beginIndex, int endIndex) 截取--->从指定位置开始截取到指定位置结束

包前不包后(包含第一个位置,不包含最后一个位置,只能取到endIndex-1处)
5)public String[] split(String regex):拆分(分割) ,按照指定的分割符将字符串拆分成字符串数组
6)public int indexOf(int ch) :返回此字符第一次在字符串中出现的索引值
public int lastIndexOf(int ch):返回此字符最后一次在字符串中出现的索引值

4.String类的转换功能

1)char[] toCharArray() 将字符串转换成字符数组
2)byte[] getBytes() 平台默认字符集编码(String--->byte[]) 和
byte[] getBytes(String charset):指定的字符集进行编码
String(byte[] bytes) :(bytes[]--->String ) 平台默认字符集解码
String(byte[] bytes,String charset) :(bytes[]--->String ) 指定字符集解码

3)public String toLowerCase():将字符串转换成小写
public String toUpperCase():将字符串转换成大写

4)万能方法: 可以将任何数据类型---->String
public static String valueOf(int i/float....Object)

编码和解码必须一致,否则乱码!

5.String的判断/替换/去除两端空格 (了解)相关功能

判断功能:
boolean contains(String str):判断大串中是否包含指定子字符串
boolean endsWith(String suffix):判断是否以指定结尾的字符串
public boolean startsWith(String prefix):判断是否指定的字符串开头
boolean equals(Object anObject)。:比较两个字符串内容是否相同
boolean equalsIgnoreCase(String anotherString) :不区分大小写比较两个字符串是否相同
public boolean isEmpty():判断字符串是否空 ,长度为0,true
空串,和空对象? 一样吗?
不一样

public String replace(char oldChar,char newChar) :替换功能
public String trim() :去除字符串两端空格 (一般io流中: 文件读写文件)

Day2

1.StringBuffer类(字符串缓冲区,线程安全的类)/StringBuilder

StringBuffer:线程安全的类,支持可变字符序列!

构造方法:
public StringBuffer() --->空参构造,初始容量16个字符
public StringBuffer(int capacity)--->指定容量大小的字符串字符串缓冲区(很少用)
public StringBuffer(String str)--->将指定的字符串内容构造到字符串缓冲区中,容量=当前str的长度+16

int length()获取字符串缓冲区长度

int capacity() :获取容量大小

1.StringBuffer的追加和插入

public StringBuffer append(任意Java类型):将指定的类型追加字符串缓冲区的序列中,返回自己本身

public StringBuffer insert(int index,String str/可以任意Java类型) 在指定位置处插入指定的数据,返回字符串缓冲区本身

2.StringBuufer的获取功能

public char charAt(int index):获取字符串缓冲区中指定位置的字符,返回指定的字符
StringBuffer的删除
StringBuffer delete(int start, int end) :删除从指定位置开始到指定位置结束(end-1)的字符,返回字符串缓冲区本身
StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回值字符串缓冲区本身

3.StringBuffer的替换功能:

public StringBuffer replace(int start,int end,String str)
将字符串缓冲区中的从指定位置开始到指定位置结束(end-1)的字符序列使用指定的字符串进行替换

4.StringBuffer的截取功能:

public String substring(int beginIndex)
public String substring(int beginIndex,int endIndex)

5.StringBuffer的特有功能:

public StringBuffer reverse()将字符串缓冲区中的字符序列进行反转

6.StringBuffer和String之间相互转换

在实际开发中,牵扯很多类型之间的相互转换
将A类型-->B类型,因为想去使用B类型的功能
   但是又可能将B类型--->A类型,最终需求的结果是A类型

   String---->StringBuffer
  StringBuffer---->String

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

        //String---->StringBuffer
        String s = "hello" ;
       /* String s = "hello" ;
        StringBuffer sb = s ;*/ //两个类型不匹配

        //方式1 :使用StringBuffer(String str)有参构造
        StringBuffer sb = new StringBuffer(s) ;
        System.out.println("sb:"+sb) ;

        System.out.println("-----------------------------------") ;

        //方式2:使用StringBuffer()空参构造,结合append(String str)追加
        StringBuffer sb2 = new StringBuffer() ;
        sb2.append(s) ;
        System.out.println("sb2:"+sb2);

        System.out.println("----------------------------------------------------");

        //StringBuffer---->String
        StringBuffer buffer = new StringBuffer("helloJavaEE") ;

        //方式1:StringBuffer--->public String toString()
        String str = buffer.toString();
        System.out.println(str) ;
        System.out.println("----------------------------------------------------") ;

        //方式2:String类----->构造方法public String(StringBuffer buffer)
        String str2 = new String(buffer) ;
        System.out.println(str2);

    }
}

2.Integer类

包装的int类型的值
四类八种基本类型---------->包装类类型(引用类型) :

                                jdk5以后的自动拆装箱
   byte   Byte
   short    Short
   int Integer
   long   Long
   float Float
   double Double
   char Character
   boolean Boolean

   基本类型引用类型 String

   String Integer int

1.Integer的构造方法:

public Integer(int value) :将int类型数据包装为Integer类型
public Integer(String s)throws NumberFormatException :将字符串类型包装Integer类型,如果字符串非数字字符串,
  就会出现NumberFormatExceptio数字格式化异常

jdk5以后的新特性:自动拆装箱 /静态导入(导入到方法的级别,前提方法必须为静态)/增强for循环/可变参数...
   基本类型会自动装箱为引用类型: int-->Integer
   引用类型会拆箱为基本类型 : Integer-->int

2.类型转换

int---->String 静态方法public static String toString(int i)
String--->int (使用居多) public static int parseInt(String s)
前后端交互:前端提交的数据几乎String类型

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


        //int--->String
        int i = 100 ;
        String result = "" ;
        //方式1:字符串拼接符号+
        result += i;
        System.out.println(result) ;
        System.out.println("---------------------------------");
        //方式2:int--->Integer---->String
        //Integer(int i) ---->publict String toString()
        Integer ig = new Integer(i) ;
        String result2 = ig.toString();
        System.out.println(result2); //"100"
        System.out.println("---------------------------------");
        //方式3:Integer的静态方法public static String toString(int i)
        String result3 = Integer.toString(i);
        System.out.println(result3);

        System.out.println("--------------------------------------") ;
       // String---->int
        String s = "20" ; //数字字符串
       //方式1:String--->Integer --->public int intValue()
        Integer ig2 = new Integer(s) ;
        int value = ig2.intValue();
        System.out.println(value); //20
        System.out.println("-----------------------------------------") ;
        //方式2:直接转换public static int parseInt(String s) throws NumberFormatException
        int value2 = Integer.parseInt(s);
        System.out.println(value2); //20


        //parseXXX方法在任意的基本类型对应的类型都存在(万能方法)
        //String--Long-->long---->Long.parseLong(字符串)
        //String--Float-->float--->Float.parseFloat(小数字符串)

    }
}

3.Character类

构造方法
   Character(char value):包装一个char字符类型 char---->Character

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

4.java.util.Date日期 (重点)

java.util.Date:特定的日期
   构造方法:
   public Date():系统时间的日期格式
   成员方法:
   public long getTime():获取指定Date对象的系统时间毫秒值

Date日期格式 ----->String日期文本 --->格式化操作

String日期文本
   2022/11/15 2022年11月15日 ----------->Date (重点 ) ---->解析
   应用场景:用户注册填写出生日期 "1995-05-27" String---->数据库Date格式

   格式化或者解析:使用DateFormat类,它是一个抽象类,不能实例化,用的抽象类的子类SimpleDateFormat

  Date日期个--->String格式化
   public final String format(Date date)
  构造方法
   SimpleDateFormat(String pattern) pattern模式 : y:代表年 yyyy 代表整个年份 :2022
   M:代表月份 MM 11 07 06
   d:月份中的日 dd 03 11 01
   H:0-23(一天的小数数) HH
   m:小时的分钟数 mm

String日期文本---->Date 解析
public Date parse(String source) throws ParseException :
   如果String日期文本和转换器SimpleDateFormat(String pattern) 里面的模式不匹配就会造成解析异常!
   String s = "2008-5-12"
   SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd ") ;//解析出问题了!

5.Random:伪随机数生成器

public Random() 构造方法:创建新的随机数生成器
   public Random(long seed) 构造方法:创建新的随机数生成器(以指定的long 的类型计算随机数):每一次均分布局一样的 (不推荐)
   成员方法
   public int nextInt():获取的int类型的取值范围
   public int nextInt(int n):[0,n)随机数

6.System类

三个成员变量 ---静态常量
   static PrintStream err“标准”错误输出流。
   static InputStream in“标准”输入流。 (InputStream:字节输入流 --读数据)
   static PrintStream out “标准”输出流。(PrintStream字节打印流--->
   OutputStream字节输出流---写/打印)

成员方法
   public static long currentTimeMillis():获取系统时间毫秒值(应用场景:计算程序的执行效率)
   public static void exit(int status):参数为0,正常终止jvm
   public static void gc():手动开启垃圾回收器
   开启垃圾回收器,会调用Object类的finalize()垃圾回收方法
   public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) :复制数组
   参数1:原数组
   参数2:原数组中的某个位置
   参数3:目标数组
   参数4:目标数组中的某个位置
   参数5:从原数组的那个位置srcPos指定长度复制到目标数组中

Day3

1.其他类之Calendar日历类

java.util.Calendar :日历类--->是一个抽象类,不能new
  这个类里面的某些功能(静态功能)---一定完了这个类的子类的实例!
创建日历实例--->public static Calendar getInstance()

   Calendar提供静态的字段(成员变量--->静态常量)
   public static final int DATE:月中的日期值
   public static final int MONTH:年中的月份值 (0-11),获取之后+1
   public static final int YEAR:年份值

Calendar提供成员方法:
   public int get(int field):获取日历的字段值
   参数就是需要通过Calendar访问的静态常量的那些字段

public abstract void add(int field,int amount) 给日历字段设置偏移量,添加或者减去 amount值

   public final void set(int year,int month,int date) 设置日历字段

2.BigDecimal:小数精确计算

构造方法
   BigDecimal(String value):参数 "小数字符串值"
   BigDecimal(int value):整数
   BigDecimal(double value):浮动类型

成员方法:
   public BigDecimal add(BigDecimal augend):加
   public BigDecimal subtract(BigDecimal subtrahend)减
   public BigDecimal multiply(BigDecimal multiplicand)乘
   public BigDecimal divide(BigDecimal divisor):除
   public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
   参数1:除数值
   参数2:scale保留小数位数
   参数3:roundingMode舍入的模式 BigDecimal提供静态常量

3.Jdk5里面其他新特性:

1)静态导入---->导入到方法的级别
   import static 包名.类名.方法名;
   前提使用静态导入,这个类的方法必须为静态

   在使用静态导入的时候,导入jdk提供的一些工具类里面静态方法的时候,我们定义的方法不能和它方法名冲突
   如果冲突了,静态导入是不识别,这个时候必须导入全限定名称 :包名.类名.方法名(xxx)

   2)可变参数,当一个方法形式参数不知道多少个,这个时候可以使用可变参数(类似一个数组)
   public 返回值类型方法名(数据类型... 参数名)

4.Colleciton集合

Colleciton:没有jdk提供直接实现,通过具体的子接口List/Set的子实现类实现

  创建集合的时候<E> :里面存储的引用类型的元素
   模拟数组,创建集合的时候就明确了集合中存储的数据类型,否则导致程序不安全!

常用基本功能:
   添加
   boolean add(E e):添加元素 E--->Object任意Java元素
   删除
   删除集合中的元素boolean remove(Object o)
暴力删除(将集合全部清空)void clear()

   判断
   boolean isEmpty():判断集合是否为空
   boolean contains(Object o):判断集合是否包含指定的元素

1.遍历

package com.qf.collection_04;
import java.util.ArrayList;
import java.util.Collection;

/**
 * @author 高圆圆
 * @date 2022/11/16 11:47
 * 遍历
 *      1)将集合转换对象数组
 *              Object[] toArray()  不推荐,还是变成数组!
 *
 *
 */
//jdk提供@SuppressWarnings("all")  解决警告问题 (实际开发中,项目打包--安装-->部署--->上线)
//@SuppressWarnings("all") //压制警告
public class CollectionDemo2 {
    public static void main(String[] args) {
        //创建一个集合--->存储String
        Collection<String>  c  = new ArrayList<>() ;
        //添加字符串数据
        c.add("hello") ;
        c.add("world") ;
        c.add("javaEE") ;
        c.add("Mysql") ;
        System.out.println(c);

        //转换成数组Object[] toArray()
        Object[] objects = c.toArray();
        for(int x = 0 ; x < objects.length ;x++){
            //objects[x]数组中---    相当于每一个元素 Object 对象名 = new String();//多态 向上转型
           // System.out.println(objects[x]);
            //遍历这些字符串并且同时它的长度
           // System.out.println(objects[x]+"---"+objects[x].length()); //Object类型没有length()
            //向下转型
            String s = (String) objects[x];
            System.out.println(s+"---"+s.length());

        }
    }
}

2.Collection的专有遍历方式:迭代器

Iterator<E> iterator()
   Iterator接口提供了功能:Object next() :获取下一个可以遍历的元素
   boolean hasNext():判断如果迭代器里面有元素,则返回true,然后在获取!

   需求:使用Collection存储String类型,并去使用迭代器将元素一一遍历,打印控制台

  1)使用Collection集合存储5个学生,使用迭代器的这种方式进行遍历!
   2)使用Collection集合存储String类型,如果这个字符串是"world",那么添加一个新的字符串数据"javaEE",
   然后遍历集合中的数据

5.List集合

List集合的特点
   允许集合元素重复(实际应用,List集合如何去重?),而且有序集合(存储和取出一致)

   List集合的特有功能:
void add(int index, E element):在指定位置插入新的元素
   E get(int index):获取指定位置处的元素
   E set(int index,E element):在指定位置处替换(修改)指定的元素
   ListIterator<E> listIterator():List集合的专有遍历-->列表迭代器

Day4

1.List去重

package com.qf.test_01;
import java.util.ArrayList;
import java.util.List;

/**
 * @author 高圆圆
 * @date 2022/11/17 9:41
 * 使用List集合存储重复String类型的数据,保证集合的元素唯一!(去重)
 */
public class ListTest {
    public static void main(String[] args) {

        //1)创建一个集合
        List<String> list = new ArrayList<>() ;

        //2)添加重复的String
        list.add("hello") ;
        list.add("world") ;
        list.add("hello") ;
        list.add("java") ;
        list.add("java") ;
        list.add("android") ;
        list.add("world") ;
        list.add("android") ;
        list.add("JavaEE") ;
        list.add("hello") ;
        list.add("android") ;

        //3)新建一个集合
        List<String> newList = new ArrayList<>() ;
        //4)遍历以前的集合
        for(String s:list){
            //一一获取以前集合中所有元素
            //使用新集合判断里面如果不包含这个元素,不重复,添加到新集合中
            if(!newList.contains(s)){
                newList.add(s) ;
            }
        }

        //5)遍历新集合
        for(String s:newList){
            System.out.println(s);
        }
    }
}
/**
 *
 * 集合的contains方法底层源码:
 * public boolean contains(Object o) {  //Object o = new String("xx") ;//多态
 *         return indexOf(o) >= 0;
 *     }
 *
 *
 *     indexOf()----->依赖于Object的equals()方法
 *     而String类型 人家已经重写了Obejct的equals()方法
 *     比较的字符串内容是否相同
 */

2.Vector集合

Vector集合:线程安全的类(底层结构:数组,查询快,增删慢)
  特有功能:
   public void addElement(E obj)将指定的元素添加Vector集合中(默认追加)
public Enumeration<E> elements():获取枚举组件接口----->类似于Collection集合的Iterator iterator()
   Enumeration接口

   boolean hasMoreElements() 判断是否有更多的元素 ----->类似于Iterator里面的boolean hasNext()
E nextElement() :获取下一个元素 ----->类似于Iterator里面的E next()

   public E elementAt(int index):通过索引值获取元素 ---->类似List集合的E get(int index)
int size():获取集合元素数

3.LinkedList集合

LinkedList:
   线程不安全,不同步,执行效率高
   底层数据结构: 线程结构之链表,查询慢,增删快!

   特有功能:
   添加元素
   public void addFirst(E e) 将指定的元素添加到链表的开头
public void addLast(E e) 将指定的元素添加到链表的末尾
public E getFirst():获取第一个元素
   public E getLast():获取最后一个元素
public E removeFirst():删除第一个并返回第一个元素
public E removeLast():删除最后一个元素并返回

4.Set集合:唯一/无序(不能保证迭代顺序)

1.hashset

Set集合:元素唯一的默认情况使用HashSet进行实例(创建对象)

HashSet的底层依赖于HashMap(哈希表结构),元素唯一,迭代顺序无法保证的!

HashSet集合保证元素唯一---底层依赖HashMap的put方法---->依赖于hashCode()/equals(),
而现在存储String类型,重写了equals和hashCode(),保证元素唯一!

2.TreeSet

TreeSet集合--->Set集合的的实现类,它应该满足保证元素唯一

  底层基于TreeMap<K,V>,它是一个红黑树(red-black-tree)
  有自然排序/比较器排序

  构造方法:
   public TreeSet():创建一个空的树,元素是按照自然排序顺序,里面的元素必须要实现Comparable接口

现在使用TreeSet存储Integer类型的元素
   结论:
   要实现自然排序,那么使用TreeSet的无参构造方法,而且存的类型一定要实现Comparable接口,重写
   compareTo(T t)方法,完成比较

TreeSet自然排序

TreeSet<Stdudent>,使用TreeSet存储自定义类型
  存储的Student类型实现Comparable,完成自然排序!
   排序条件(主要条件)
   按照学生的年龄从小到大排序

   自己的分析次要条件:

  使用TreeSet<Student>,按照自然排序排序
主要条件:
   按需学生的姓名的长度从小到大比较
   次要条件:长度相同,比较姓名内容是否相同

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建TreeSet集合
        TreeSet<Student> ts = new TreeSet<Student>() ;//无参构造方法,自然排序

        //创建一堆学生
        Student s1 = new Student("gaoyuanyuan",32) ;
        Student s2 = new Student("gaoyuayuan",32) ;
        Student s3 = new Student("liushishi",36) ;
        Student s4 = new Student("wangbaoqi",36) ;
        Student s5 = new Student("wenzhang",28) ;
        Student s6 = new Student("wenzhang",28) ;
        Student s7 = new Student("mabaoguo",65) ;
        Student s8 = new Student("mabaoguo",56) ;
        Student s9 = new Student("gaoyuanyuan",35) ;
        Student s10 = new Student("zhangwen",35) ;

        //添加
        //Student类没有实现自然排序接口
        //java.lang.ClassCastException: com.qf.treeset_05.Student cannot be cast to java.lang.Comparable
        ts.add(s1) ;
        ts.add(s2) ;
        ts.add(s3) ;
        ts.add(s4) ;
        ts.add(s5) ;
        ts.add(s6) ;
        ts.add(s7) ;
        ts.add(s8) ;
        ts.add(s9);
        ts.add(s10);

        //遍历
        for(Student s:ts){
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

TreeSet比较器排序

存储的Student类型实现Comparable,完成比较器排序
* 排序条件(主要条件)
* 按照学生的年龄从小到大排序
* 比较强排序:
* TreeSet有参构造方法
* public TreeSet(Comparator<? super E> comparator) 按照比较强排序

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

        //创建一个TreeSet集合
        //public TreeSet(Comparator<? super E> comparator) 按照比较强排序
        //比较器排序方式1:自定义一个类实现Comparator接口
       // MyComparator my = new MyComparator() ;  //具体类对象
        //Comparator<Student> my = new MyComparator() ;  //接口多态
       // TreeSet<Student> ts = new TreeSet<>(my) ;

        //方式2:public TreeSet(Comparator<? super E> comparator) 按照比较强排序,使用接口匿名内部类

        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //按照学生的年龄从小到大排序(主要条件)
                //s1---->this
                //s2---->s
                int num = s1.getAge() - s2.getAge() ;
                //次要条件:年龄相同,比较姓名是否一致
                int num2 = (num==0)?(s1.getName().compareTo(s2.getName())):num ;
                return num2;
            }
        }) ;
        //创建学生对象
        Student s1 = new Student("wenzhang",25) ;
        Student s2 = new Student("wenzhang",25) ;
        Student s3 = new Student("gaoyuanyuan",25) ;
        Student s4 = new Student("luozhixiang",32) ;
        Student s5 = new Student("gaoyuanyuan",22) ;
        Student s6 = new Student("mayili",22) ;
        //添加
        ts.add(s1) ;
        ts.add(s2) ;
        ts.add(s3) ;
        ts.add(s4) ;
        ts.add(s5) ;
        ts.add(s6) ;
        for(Student s:ts){
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

Day5

1.Map(针对键有效,键必须唯一!)的基本功能

添加:
   V put(K key, V value):添加键值对元素,返回值什么意思?
   map针对键有效,键如果唯一的,返回是null;
   如果重复,将后面的键对应的值把前面的值覆盖了,返回第一次键对应的值
   删除:
   V remove(Object key):删除键,返回键对应的值
   void clear():暴力删除,将map清空掉
判断:
   boolean containsKey(Object key):判断Map集合是否包含指定的键,包含返回true,否则false
   boolean containsValue(Object value):判断Map集合是否包含指定的值,包含则返回true,否则false
   boolean isEmpty() :判断集合是否为空

2.面试题

Map和Collection的区别 ?
   Collection<E>:单例集合,只能存储一种引用类型数据遍历方式和Map不同;
   Collection集合的应用范围大:
   ArrayList
Vector
   LinkedList
   它里面的部分集合和Map有关联(HashSet--->依赖HashMap / TreeSet---->依赖于TreeMap)
Map<K,V>,双列集合---->可以存储键值对("夫妻对")
   遍历方式:通用方式获取所有的键,通过键找值!
   应用范围:
   HashMap---->存储和获取 (默认使用)
   TreeMap---->存储---获取(按照排序规则排序)
Map---->称为 "实体"
   Map<Integer,Product>

3.遍历Map集合的方式

1)获取所有的键的集合 Set<K> keySet() (通用的遍历方式) --->"获取所有的丈夫",丈夫自己妻子
结合 V get(Object key):通过键找值
2)Set<Map.Entry<K,V>> entrySet() :获取Map结合的键值对对象 ---->"获取所有结婚",找丈夫,找妻子

HashMap---->put方法---->依赖于hashCode()+equals()方法能够保证键唯一!
存储String,String类型重写了hashCode()+equals()方法,比较键的字符串内容是否相同!

4.HashMap<K,V>

存储键值对元素,保证K唯一,根据的类型有关系
  如果K是自定义类型,
  HashMap<Student,String> ,考虑保证学生对象唯一!
   Key:Student类型
   Value:String类型

   要针对键有效,需要键的类型,需要重写equals()和hashCode()
equals():比较内容是否相同, hashCode():比较每一个成员信息的哈希码值是否一样

5.TreeMap<K,V>

针对键有效,排序(自然排序/比较器排序)
构造方法:
   public TreeMap():自然排序
   public TreeMap(Comparator<? super K> comparator):比较器排序

   如果键是自定义类型,键必须唯一,而且需要有排序规则!

  TreeSet<Emplyee,String> 来按照学生的年龄从小到大排序(主要条件)

6.java.util.Collections:针对集合操作工具类

常用的方法
   二分搜索法,在指定List集合中查询指定元素第一次出现索引值 (集合的元素有序)
public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)
public static <T> T max(Collection<? extends T> coll):针对Collection集合获取最大值(自然顺序比较获取最大值)
  public static <T> T min(Collection<? extends T> coll):针对Collection集合获取最小值(自然顺序比较获取最小值)
public static void reverse(List<?> list):将List集合的元素反转
public static void shuffle(List<?> list):针对List集合随机置换
public static <T extends Comparable<? super T>> void sort(List<T> list):针对List集合按照自然顺序排序
public static <T extends Comparable<? super T>> void sort(List<T> list,Comparator<T> com):
  针对List集合按照比较器进行排序