第五周周报

1.描述Object类的toString()方法?
建议所有子类重写toString(),结果是描述成员信息表达式(更容易让人阅读)String类的public String toString()-----> return this;

2.列举出String类中常用的获取功能 (4个)
char charAt(int index)   获取指定索引的字符,
String concat(String anotherStr)拼接功能
String[] spilt(String speatorStr) 将字符串按照指定的分割符号拆分成字符串数组
String substring(int beginIndex) 从指定位置开始默认截取到末尾
String substring(int beginIndex,int endIndex) 从指定位置开始截取到指定位置结束(endIndex-1处)
int indexOf(String str) 查询指定字符串在大串第一次出现的索引值
int compareTo(String anotherStr) 字符串按照字典顺序比较
    String s1 = "abc" ;
    String s2  = "cba" ;
    System.out.println(s1.compareTo(s2)) ;//'a'-'c'

3.列举出String类的转换功能(5个)
可以将任意Java类型转换成String (int/float/double/byte/short/long/char/boolean/Object)
public static String valueOf(任意Java类型){}
将字符串转换成字符数组
char[] toCharArray(){}
将字符串转换成字节数组
byte[] getBytes(){}
将字节数转换成字符串---String的构造方法
String(byte[] bytes)
String(byte[] bytes,int index,int length)从字节数组的某个位置开始,指定长度,转换成字符串  
将字符数组转换成字符串
String(char[] chs)/String(char[] chs,int index,int length)    
将字符串转换大写
String toUpperCase(){}
将字符串转换成小写
String toLowerCase(){}

4.String类的特点?
String是一个常量,不可变的字符序列,一旦被赋值,其值不可更改!

选择排序的思想以及核心代码体现
思想：使用0角标对应的元素以此和后面的元素进行比较，前面的值比后面的值大，将小的值往前放，第一次
class Array{
public void Array1(int []arr){
for(int i=0;i<arr.length-1;i++){
for(int x=i+1;x<arr.length;i++){
     if(arr[i]>arr[x]){
int temp=arr[i];
arr[i]=arr[x];
arr[x]=temp;
           }
          }
        }
     }

StringBuffer
构造方法：public StringBuffer（）---->空参构造，初始容量16个字符；
public StringBuffer（int capacity）---->指定容量大小的字符串缓冲区，容量=当前的str的长度加16
int length（）获取字符串缓冲区长度
int capacity（）：获取容量大小
StringBuffer sb = new StringBuffer() ;---->空参构造；
StringBuffer sb2 = new StringBuffer(20) ;---->指定容量20字符串缓冲区
StringBuffer的追加和插入
public StringBuffer append（任意java类型）：将指定的类型追加字符串缓冲区的序列返回自己本身；
public StringBuffer insert(int index,String str/可以任意Java类型) 在指定位置处插入指定的数据,返回字符串缓冲区本身
 
StringBuufer的获取功能
          public char charAt(int index):获取字符串缓冲区中指定位置的字符,返回指定的字符
  StringBuffer的删除
          StringBuffer delete(int start, int end)  :删除从指定位置开始到指定位置结束(end-1)的字符,返回字符串缓冲区本身
          StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回值字符串缓冲区本身
 StringBuffer的替换功能:
         public StringBuffer replace(int start,int end,String str)
                     将字符串缓冲区中的从指定位置开始到指定位置结束(end-1)的字符序列使用指定的字符串进行替换
 
 StringBuffer的截取功能:
           public String substring(int beginIndex)
           public String substring(int beginIndex,int endIndex)
 StringBuffer的特有功能:
 *public StringBuffer reverse()将字符串缓冲区中的字符序列进行反转
类型转换：
String--->StringBuffer
方法一：
String s = "hello" ;
StringBuffer sb = new StringBuffer(s) ;
System.out.println("sb:"+sb) ;
方法二：
String s = "hello" ;
StringBuffer sb2 = new StringBuffer() ;
sb2.append(s) ;
System.out.println("sb2:"+sb2);
StringBuffer----->String
方法一：
StringBuffer buffer = new StringBuffer("helloJavaEE") ;
String str = buffer.toString();
System.out.println(str) ;
方法二：
StringBuffer buffer = new StringBuffer("helloJavaEE") ;
String str2 = new String(buffer) ;
System.out.println(str2);
String和StringBuffer/StringBuilder的区别?
String:是一个常量,一旦被赋值,其值不能被更改 ,不可变的字符序列!
作为形式参数,形式参数的改变不影响实际参数(和基本类型作为形式参数传递的效果一致 ,特殊的引用类型)
 StringBuffer:支持可变的字符串序列,线程安全的类--->同步的--->执行效率低
StringBuffer的大部分功能--->synchronzied:同步锁(悲观锁)(多线程去讲)
作为形式参数,形式参数的改变直接影响实际参数
StringBuilder:和StringBuffer具备相互兼容的API,线程不安全的类---不同步的---->执行效率高
单线程程序(只考虑效率)中,使用StringBuilder去替代StringBuffer
多线程环境下(要考虑安全),使用StringBuffer
Integer的构造方法:
public Integer(int value) :将int类型数据包装为Integer类型
public Integer(String s)throws NumberFormatException :将字符串类型包装Integer类型,如果字符串非数字字符串,
就会出现NumberFormatExceptio数字格式化异常
jdk5以后的新特性:自动拆装箱      /静态导入(导入到方法的级别,前提方法必须为静态)/增强for循环/可变参数...
      基本类型会自动装箱为 引用类型:    int-->Integer
      引用类型会拆箱为 基本类型  :     Integer-->int
类型转换
int---->String;
Interger类的静态方法
public static String toString(int i);
方式一：
        int i = 100 ;
        String result = "" ;
        result += i;
        System.out.println(result) ;
方式二：
        int i = 100 ;
        Integer ig = new Integer(i) ;
        String result2 = ig.toString();
        System.out.println(result2);
方式三：
        int i = 100 ;
        String result3 = Integer.toString(i);
        System.out.println(result3);

String------>int;
public static int parseInt（String numberStr）；
方式1:
        String s = "20"
        Integer ig2 = new Integer(s) ;
        int value = ig2.intValue();
        System.out.println(value);
        
方式2:  String s = "20"
        int value2 = Integer.parseInt(s);
        System.out.println(value2);
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指定长度复制到目标数组中
 long start =System.currentTimeMillis() ;
        for(int x = 0 ; x < 10000; x ++){
            System.out.println(x+"hello") ;
        }
  long end =System.currentTimeMillis() ;
 System.out.println("共耗时:"+(end-start)+"毫秒");
java.util.Date:特定的日期
构造方法:
  public Date():系统时间的日期格式
成员方法:
  public long getTime():获取指定Date对象的系统时间毫秒值
     Date date  = new Date()  ;
     System.out.println(date) ; Date日期格式
     public long getTime():获取指定Date对象的系统时间毫秒值
     long time = date.getTime();
     System.out.println(time);
 SimpleDateFormat(String pattern)   
pattern：
y：代表年
M：代表月份
d：月份中的日
H:一天的小时数（0-23）
m：小时的分钟数
public class DateDemo2 {
    public static void main(String[] args) throws
ParseException {
将Date---->String 格式化
Date date = new Date() ;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
        String dateStr = sdf.format(date);
        System.out.println(dateStr);
给定一个日期文本 String---->Date (重点)
        String str = "2020-12-31" ;
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd") ;
        Date date2 = sdf2.parse(str);
        System.out.println(date2);

Character(char value):包装一个char字符类型  char---->Character
成员方法
public static boolean isDigit(char ch):判断是否为数字字符
public static boolean isUpperCase(char ch):判断是否为大写字母字符
public static boolean isLowerCase(char ch):判断是否为小写字母字符

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) 设置日历字段

使用List集合存储重复的String类型数据，保证集合的元素唯一（去重）

集合和数组的区别：
长度区别：数组长度固定，集合长度可变；
存储数据类型的区别：数组:既可以存储基本类型也可以存储引用了类型，但是这些数据类型必须一致
集合：只能存储引用数据类型，如果集合不带泛形，那么本身就可以存储任意类型数据
Collection的专有遍历方式:迭代器  Iterator<E> iterator()
Iterator接口提供了功能:Object next():获取下一个可以遍历的元素
 boolean hasNext():判断如果迭代器里面有元素,则返回true,然后在获取!
需求:使用Collection存储String类型,并去使用迭代器将元素一一遍历,打印控制台
List集合的特点
允许集合元素重复(实际应用,List集合如何去重?),而且有序集合(存储和取出一致)
List集合的特有功能:
void add(int index, E element):在指定位置插入新的元素
E get(int index):获取指定位置处的元素
E set(int index,E element):在指定位置处替换(修改)指定的元素
ListIterator<E> listIterator():List集合的专有遍历-->列表迭代器
dk5新特性 增强for循环---->目的 为了替代迭代器(集合,存储引用类型)
for(泛型里面存储的数据类型 变量名 : 集合或者数组名称){
             使用变量名
          }
增强for的特点: 前提条件:集合或者数组对象不能为null,否则NullPointerException
3.List三个子实现类的特点?
ArrayList:
底层数据结构是数组,查询快,增删慢
线程不安全,不同步----执行效率高  
扩容机制是1.5倍
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():获取集合元素数
LinkedList
底层数据结构是链表,查询慢,增删快
线程不安全,不同步--->执行效率高
应用场景:添加操作---每次将数据添加集合的前面/删除末尾元素
获取类的字节码文件的方式
三种方式
1)Object类的getClass()--->使用任意Java对象调用 Student s = new Student() ;
Class clazz1 = s.getClass()
//class 包名.类名
2)任意Java类型的class属性 定义了学生Student
Class clazz2 = Student.class;
3)Class类提供静态方法forName("全限定名称") ;
反射中用---->使用居多,参数是String字符串,可以在配置文件中进行配置!
全限定名称:包名.类名

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

TreeSet集合存储自定义类型如何实现自然排序和比较器排序
TreeSet基于TreeMap红黑树结构,存储第一个元素---根节点,后面的元素依次和根节点比较
小了,左子节点
大了,右子节点
相等,存以前的值
自然排序(默认使用的这种:大部分常用String/Integer/Character 都实现Comparable)
TreeSet<自定义类型>,如果要实现自然排序,使用TreeSet的无参构造方法 public TreeSet<E>()
 自定义类型必须实现一个接口:Comparable<T>--->实现public int compareTo(T t){排序规则...}

比较器排序
    TreeSet<E>(Comparator<T> com):有参构造方法
    方式1:自定义一个类 实现Comparator接口---实现 public int compare(T t1,T t2){排序规则...}
    方式2:使用接口的匿名内部类
    TreeSet<自定义类型> ts = new TreeSet<>(new Comparator<自定义类型>(){
        public int compare(自定义类型 t1,自定义类型 t2){排序规则...}
    }) ;

选择排序采用两种方法：

import java.util.ArrayList;
import java.util.List;
public class ListTest {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("hello");
        list.add("java");
        list.add("java");
        list.add("hello");
        list.add("java");
        List<String>newList=new ArrayList<>();
       for (String s:list){
           if (!newList.contains(s) ){
               newList.add(s);
           }
       }
        for (String s:newList){
            System.out.println(newList);
        }
    }
}
--------------------------------------------------------
//使用0角标对应的元素依次和后面元素比较,如果后面元素和前面的元素重复,将后面的元素干掉,
 for(int x=0;x<list.size()-1;x++){
            for (int y=x+1; y< list.size();y++){
               if(list.get(x).equals(list.get(y))){
                   list.remove(y);
                   y--;
               }
            }
        }
        for (String s:list){
            System.out.println(s);
        }

用List集合存储自定义类型:使用新建集合思想去重，contains（）底层依赖于Object的equals而object的equals方法默认比较“==”两个对象的地址值是否一样，存储自定义类型保证元素唯一，自定义类型重写equals（）和hashcode（），成员信息是否一样，如果一样，还要比较成员的哈希码值是否一样，如果都相同就是同一个人。

代码示例：

public class Student {
    private String name;
    private  int  age;
    public Student() {
    }
    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        if (age!=student.age)return false;
        return name.equals(student.name);
    }
    @Override
    public int hashCode() {
        int result=name.hashCode();
        result=31*result+age;
        return result;
    }
}

//测试类
import java.util.ArrayList;
import java.util.List;
public class ListTest1 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        Student s1 = new Student("高圆圆",32) ;
        Student s2 = new Student("高圆圆",32) ;
        Student s3 = new Student("高圆圆",32) ;
        Student s4 = new Student("文章",35) ;
        Student s5 = new Student("文章",32) ;
        Student s6 = new Student("赵又廷",36) ;
        Student s7 = new Student("赵又廷",36) ;
        Student s8 = new Student("马伊琍",38) ;
        list.add(s1) ;
        list.add(s2) ;
        list.add(s3) ;
        list.add(s4) ;
        list.add(s5) ;
        list.add(s6) ;
        list.add(s7) ;
        list.add(s8) ;
        List<Student> newList=new ArrayList<>();
        for (Student s:list){
            if (!newList.contains(s)){
                newList.add(s);
            }
        }
        for (Student s:newList){
            System.out.println(s.getName()+"----"+s.getAge());
        }
    }
}

使用LinkedList集合模拟栈结构（代码示例）：

import java.util.LinkedList;

public class MyStack<T> {
    private LinkedList<T> lk;//提供成员变量
    public MyStack() {
      lk  = new LinkedList<>();//创建LinkedList对象
    }
    public void addElement(T t){
        lk.addFirst(t);//链表开头加入元素
    }
    public T getElement(){
        return lk.removeFirst();

    }
    public boolean MyStackEmpty(){
        return  lk.isEmpty();
    }

}
//测试类
public class LinkedListTest {//使用LinkedList来模拟栈结构特点:先进后出
    public static void main(String[] args) {
    MyStack<String> myStack= new MyStack<>();//本质创建了Linkedlist集合对象
  myStack.addElement("hello");
  myStack.addElement("java");
  myStack.addElement("javaee");
  myStack.addElement("name");
  while (!myStack.MyStackEmpty()){//判空
      System.out.println(myStack.getElement());
  }
    }

}

Vector集合遍历（两种方式）：

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemos {
    public static void main(String[] args) {
        Vector<String> vector=new Vector<>();//创建集合；
        vector.add("hello");
        vector.add("nihao");
        vector.add("java");
        vector.add("world");
        vector.add("javaee");
        System.out.println(vector);
        for (int x=0; x<vector.size();x++){//遍历
            String s = vector.elementAt(x);
            System.out.println(s);
        }
        System.out.println("----------------------------------");
        Enumeration<String>en=vector.elements();//遍历
        while (en.hasMoreElements()){//判空
            String s = en.nextElement();
            System.out.println(s);
        }
    }
}