javaEE总结_week4

Character类:

 概述:char类型的包装类类型:

** 构造方法:**

Character (char value): //将一个char类型转换成Character 类对象

** 常用方法:**

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

Data类:

** 构造方法:**

 public Data(): 无参构造: 创建日期对象,获取当前系统时间日期格式
 public Data(long date): 创建日期对象,和1970年1月1日时间有关系

** 成员方法:**

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

Date重点:日期文本格式和Date如何转换?

 *     String日期文本格式  "2022-8-13"------>java.util.Date 日期格式
 *      Date日期格式 转换成   String
 *
 *    使用中间桥梁:DateFormat类 是一个抽象类,不能实例化,jdk提供更具体的子类:SimpleDateFormat
 *
 *      构造方法
 *             public SimpleDateFormat(String
 pattern)
 *              yyyy:年  MM:月  dd:月中日期  HH:小时  mm:分钟  ss:秒
 *
 *        成员方法:
 *              Date---->String    
 public String foramt(Date date) :格式化
 *
 *              String--->Date:    
 public Date  parse(String Str) throws ParseException: 解析
 *                                  这个本身可能出现异常,如果解析的字符串的格式和 pattern参数的模式匹配,就出错了,解析失败!

Random类:

** 概述:随机数生成器**

构造方法:

创建随机数生成器对象:然后调用方法 
  1) Random(),无参构造之后调用nextInt()/nextInt(int n);//每次产生的随机数不同
  2)Random(long seed):调用nextInt()/nextInt(int n);//每次产生的随机数相同(不推荐)

成员方法:

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

实际用途:
有一个集合,集合里面存储的随机数,而且保证集合的元素必须唯一,将元素一一遍历出来;

•     List<Integer>:集合可以重复
  

•        Set:集合不可以重复
  

System类

常用功能:

    1)public static void exit(int status): //参数为0,退出Jvm(正常终止),如果参数不为0,属于异常终止;
    2)public static long currentTimeMillis(): //获取当前系统时间毫秒值
     //场景;后面使用IO流传输文件 查看所耗时间(比较耗时的操作)
     3) public static void arraycopy(Object str, (原数组)
           int srcPos,      (原数组中的某个位置)
           Object dest,    (目标数组)
           int destPos,    (目标数组位置)
           int length        (复制的长度)
           )      //复制数组的一部分
     4)public static void gc():  //手动开启垃圾回收器,回收没有更多引用的对象,实际会调用Object类的finalize()方法  (一般不怎么使用)

集合:

面试题:(数组和集合的区别)

   1)长度(容量) 的区别:
       数组长度固定;
       集合长度可变;
   2)存储数据类型的区别:
      数组可以存储java中的任意数据类型(基本数据类型,引用数据类型)
      集合:只能存储引用数据类型;
  3)存储元素的区别:
     数组:这个容器只能存储同一种数据类型的元素
     集合:可以存储不同引用数据类型的元素

collection:集合的顶层次的根接口:

** 集合中常用的操作方法:**

boolean  add(E e):E------->Element:元素---->理解为Object任何java引用类型
boolean constants(Object o):判断集合中元素是否包含某元素
boolean isEmpty():判断集合是否为空
int size();  获取集合中元素个数
Object[] toArray():  将集合转换成对象数组
void remove(Object o):移除集合中指定的元素
void clear():  清空集合

Iterator迭代器:

迭代器:-------是集合遍历元素的一种专有方式
迭代器的使用原理:(大致翻阅源码)

 
//迭代器接口
interface Iterator<E>{
        boolean hasNext(); //判断是否有下一个元素可以迭代(遍历)
        E next(); //获取下个元素
}
//规定获取迭代器的方法
public interface Iterable<T>{   //最顶层次的接口
        Iterator<E> iterator();//获取集合迭代器的
}
//接口
interface Collection<E> extends Iterable<T> // T --->Type类型 {
        Iterator<E> iterator();//获取集合迭代器的           继承父接口过来的
}

//子接口
interface List<E>  extends Collection<E>{
        //iterator()继承过来

}
//具体的实现类
class ArrayList<E> implements List<E>{
    //将父接口--->继承的父接口----里面所有的抽象方法都重写
        public Iterator<E> iterator() { //具体的子类实现类这个方法
                return new Itr();
        }

        //私有的成员内部类
        private class Itr implements Iterator<E> { //实现迭代器接口的方法
    
        Itr() {}
    
        public boolean hasNext() { //实现了迭代器hasNext()是否有下一个元素
           ...
        }
    
        @SuppressWarnings("unchecked")  //jdk提供的注解@SuppressWarnings:压制警告的
        public E next() {       //实现了获取下一个元素的方法
                ...
        }
}

Iterator<引用类型> 集合迭代器对象 =  collection集合对象.iterator() ;
本质就是实现了Iterator接口的子实现类,具体的类名是ArrayList集合的内部类Itr来实现的;

** list集合的三个子实现类的特点:**

   1)ArrayList: 底层是数组(普遍使用,效率高,不安全)
   2)LinkedList:底层是链表(添加,删除/修改比较快,查询比较慢的)
   3)Vector: 底层是数组(效低  ,安全)

集合常见的五种遍历方式:

  //toArray()转换对象数组遍历(方法一)
  List<String> list = new List<>();
  c.add("元素");
  Object[] obj  = list.toArray();
  for(int x=0 ;  x<obj.length; x++){
     String s = (String)obj[x]; //强制类型转换
     System.out.println(s);
  
  }
  //普通for循环实现(方式二)
  for(int x = 0; x<list.size(); x++){
  
  System.out.println(list.get(x));

  }
  //Collection迭代器(方式三)
  Iterator<String> it =  list.iterator(); ///集合对象调用迭代器
  while(it.hasNext()){     //z判断是否有下个元素
  System.iout.println(it.next());
  
  }
  //List集合的专有迭代器(方式四)
  ListIterator<String> lt = list.iterator<>();
  while (lt.hasNext()){
  
  System.out.println(it.next());
  }
  //ListIterator子接口提供的反向遍历
ListIterator<String> lt = list.iterator();
while(lt.hasPrevious()){
System.out.println(lt.previousNext());

}
//增强for循环(方式五)
for(String s:list){
System.out.println(s);
}

集合去重:(面试题)

思路:
1)假设就创建了List集合对象,里面存储的字符串数据
2)创建一个新的空List集合
3)遍历以前的集合,获取以前的集合所有元素并在新的集合中加判断,如果新的集合中没有就添加,否则不添加
4)最终,遍历新的集合,就是一个不重复的新集合

  //代码实现
  List<String> list = new ArrayList<>();
  list.add("元素");
   List<String> newList = new ArrayList<>();
   for(String s:list){
   while(!newList.contains(list)){ //判断内容是否唯一,
   newList.add(s);
     }
   }
   for (String s1 : newList){    System.out.println(s1);
   }

注意:
此处使用的是String类,是jdk提供的该类已经实现了equals()和hasCode()方法,如果是自动定义类的话,就需要在自定义类中实现equals()方法和hasCode()方法;
此处查重时用到的 contains(Object o),而该方法底层依赖于indexOf():
public boolean contains(Object o ){
return indexOf(o); //查询元素
}
indexOf()方法又依赖于Object类的equals()方法,所以最终比较的是字符串的内容而并不是地址;

public int indexOf(Object o) {

if (o == null) { // 查找的元素为空

for (int i = 0; i < size; i++) // 遍历数组，找到第一个为空的元素，返回下标

if (elementData[i]==null)

return i;

} else { // 查找的元素不为空

for (int i = 0; i < size; i++) // 遍历数组，找到第一个和指定元素相等的元素，返回下标

if (o.equals(elementData[i]))

return i;

}

return -1;

}

选择排序:

思想:

  先在未排序序列中选择索引为0的元素,然后拿出来与后面的元素序列一一比较,小的替换到前面,大的往后面替换,总共需要比较length-1 次;

     //代码体现   
     public class SelectSort { 
     public static void main(String[] args) {        int[] srr = {1,5,6,5,8,7};       
     int[] ints = selectSort(srr);        
     
     System.out.println(Arrays.toString(ints));  
     }    
     public static int[] selectSort(int[] arr){      
     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;               
          }        
     
         }      
     }        return arr;   
     }}

Vector:

概述:

 Vecter集合,底层数据结构是  数组;是List集合接口的子实现了之一,遍历元素可以已使用List集合的五中遍历方式,但是他有自己独有的功能;
 添加元素:
    public void addElement(E object):添加任意元素 如果E类型确定了,就只能添加这个数据两类型
   遍历元素方式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()获取集合长度(集合元素数量)

这个集合特点:底层数据结构数组(查询,更新元素比较快,添加,删除比较麻烦的),
 线程安全的类---同步的---执行效率比较低(多线程环境下使用安全性比较大的类)

LinkedList集合

概述:
LinkedList集合:底层数据结构是一种链表,链表的**特点: **查询慢(每次需要冲链表头查询到末尾),
增删快;
线程不安全的,不同步,执行比较高!

** 特有功能:**

        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() :将第一个元素删除并返回

set集合

Set集合的特点:
保证元素唯一,而且不能保证迭代次序
唯一,无序性(元素不重复,不能保证顺序—哈希表(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,比较内容是否相容!



  HashSet<Student>如果存储的是自定义对象,必须自定义的类要重写Object类的equals和hashCode(),否则不是唯一的