Java语言进阶篇基本概念

Posted 2021-03-16 zws-bugging

一、Object类、常用API

1、Object类

 此类事Java语言中的根类，即所有类的父类。如果一个类没有指定父类，那么默认则继承自Object类。

2、日期时间类

（1）Date类（特定的瞬间）、format类（日期/时间格式化子类的抽象类）

//创建日期对象
Date date = new Date();
    	 
//创建日期格式化对象，指定输出格式，注意：y年M月d日H时m分s秒
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = df.format(date);

System.out.println(str);//2020-01-06 19:41:56

（2）Calendar类（日历类，方便获取各个时间属性）

  常用的方法：

 1）get(int field）：返回给定日历字段的值

 2）set(int field，int value）：将给定的日历字段设置为给定值。

 3）public abstract void add(int field,int amount)：根据给定的日历字段添加或减去指定的时间量。

 4）public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对 象。Calendar类中提供很多成员常量，代表给定的日历字段：

     

//创建Calendar对象
        Calendar cal = Calendar.getInstance();
//设置年
int year = cal.get(Calendar.YEAR);
//设置月
int month = cal.get(Calendar.MONTH)+1;
//设置日
int dayofMonth = cal.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"年"+month+"月"+dayofMonth+"日");//2020年1月6日

getTime方法：

//创建Calendar对象
 Calendar cal = Calendar.getInstance();
 Date date1 = cal.getTime();
 System.out.println(date1);//Mon Jan 06 20:21:05 CST 2020

3、System类（提供了大量的静态方法，可以获取与系统相关的星系或系统级操作）

 常用的方法：

 public static long currentTimeMillis()：返回以毫秒为单位的当前时间。

 public static void arraycopy(Object src,int srcpos,Object dest,int despos,int length)：将数组中指定的数据  拷贝到另一个数组中。（src为源数组，srcpos源数组索引起始位置，dest 目标数组，despos目标数组索引位置，length复制元素个数）

int []src = new int[] {1,2,3,4,5};
        
int []dest = new int[] {6,7,8,9,10};
        
System.arraycopy(src,0,dest,0,3);
        //src数组元素1，2，3，4，5
        //dest数组元素1，2，3，9，10

4、StringBuilder类

由于String 对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。

String s = "hello";
s+="world";
System.out.println(s);

它的内部有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder 会 自动维护内容，默认16字符空间，超过自动扩充）

public StringBuilder()：构造一个空的StringBuilder容器。

public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

StringBuilder sb1 = new StringBuilder();
System.out.println(sb1);//空白
//使用带参构造
StringBuilder sb2 = new StringBuilder("itcast");
System.out.println(sb2);

5、包装类

（1）基本类型与字符串之间的转换 

public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

//如 int num = Integer.parseInt("100");
//注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常

二、　Collection、泛型

 1、Collection集合

 集合是java提供的一种容器，可以存储多个数据。

 集合与数组都是容器，它们有啥区别?

 1）数组的长度是固定的，集合的长度是可变。

 2）数组中存储的是同一种类型的元素，可以存储基本数据类型值，集合存储的都是对象。而且对象的类型可以不一致。在开发中一般对象多的时候，使用集合进行存储。

（1）集合框架

（2）Collection常用的功能

   public boolean add(E e)：把给定的对象添加到当前集合中。
   public void clear() :清空集合中所有的元素。
   public boolean remove(E e): 把给定的对象在当前集合中删除。
   public boolean contains(E e): 判断当前集合中是否包含给定的对象。
   public boolean isEmpty(): 判断当前集合是否为空。
   public int size(): 返回集合中元素的个数。
   public Object[] toArray(): 把集合中的元素，存储到数组中。

        // 创建集合对象使用多态形式
	Collection<String>coll=newArrayList<String>();
	 coll.add("张三");
	 coll.add("李四");
	 coll.add("王五");
	 coll.add("周六");
	 coll.add("88520");
	 
	 System.out.println(coll.contains("王五"));//true，判断王五是否存在集合中
	 
	 System.out.println(coll.remove("88520"));//删除集合中的与元素
	 System.out.println(coll.size());//集合中有几个元素
	  
	 Object[] objects=coll.toArray();// 遍历数组
	 for (int i=0; i<objects.length; i++) {
		 System.out.println(objects[i]);
	     }
	 
	 coll.clear();//清空集合
	 System.out.println(coll.isEmpty());//判断集合是否为空

2、Iterator迭代器

 在程序开发中，经常需要遍历集合中的所有元素。

 public Iterator iterator()：获取集合对应的迭代器，用来遍历集合中的元素。

 迭代：即Collection集合元素的通用获取方式。在去元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续判断，如果还有就再取出来。一直把集合中的所有元素全部取出。

 public E next()：返回迭代的下一个元素。

 public boolean hasNext()：如果仍有元素可以迭代，则返回true。 

                Collection<String>coll = new ArrayList<String>();
		coll.add("串串星人");
		coll.add("吐槽星人");
		coll.add("汪星人");//遍历，使用迭代器遍历每个集合对象都有自己的迭代器
		
		Iterator<String>it= coll.iterator();//  泛型指的是迭代出元素的数据类型
		while(it.hasNext()){ //判断是否有迭代元素
			String s = it.next();//获取迭代出的元素
			System.out.println(s);        
		}

（1）迭代器的实现原理：在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

（2）增强for

   增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

int[] arr= {3,5,6,87};//使用增强for遍历数组
for(inta : arr){//a代表数组中的每个元素
System.out.println(a);
}

 3、泛型（可以在类或方法中预支地使用未知地类型）

   在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

  定义和使用含有泛型地类

//自定义泛型类
class Myclass<Mvp>{//没有Mvp类型，在这里代表未知的一种数据类型 未来传递什么就是什么
	private Mvp mvp;
	
	public void setMvp(Mvp mvp) {
		this.mvp = mvp;
	}
	
	public Mvp getMvp() {
		return mvp;
	}
}
public class My {
     public static void main(String [] args) {
    	 Myclass<String> m = new Myclass<String>();//
    	 
    	 
    	 m.setMvp("MVP");
    	 System.out.println(m.getMvp());
    	 
    	 Myclass<Integer> n = new Myclass<Integer>();
         n.setMvp(123);
         System.out.println(n.getMvp());
     }
}

　定义含有泛型的方法

   修饰符<代表泛型的变量> 返回值类型 方法名(参数){ }  //调用方法时，确定泛型的类型

   定义含有泛型的接口

   修饰符 interface 接口名<代表泛型的变量>{  }

   使用格式：1）定义类时确定泛型的类型   2）始终不确定泛型的类型，直到创建对象时，确定泛型的类型

   泛型通配符：不知道使用什么类型来接收的时候，此时可以使用？，？表示未知通配符。

三、List、set、数据结构、Colections

   1、数据结构（数据存储的常用结构有：栈、队列、数组、链表和红黑树）

   1）栈：stack，堆栈，它是运算受限的线性表，其限制是仅允许在表的一段进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。特点：先进后出。

   压栈：就是存元素。即把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。

   弹栈：就是取元素。即把栈的顶端位置元素取出，栈中已有元素一次向栈顶方向移动一个位置。

   2）队列：queue，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端删除

   特点：先进先出。

   3）数组：Array，是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。

   对元素的存储有以下特点

   查找元素快：通过索引，可以快速访问指定位置的元素。

   增删元素慢：（省略）

   4）链表：linked list ，由一系列结点node（链中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

   对元素的存储有以下特点：

    多个结点之间，通过地址进行连接。

    查找元素慢：需要通过连接的节点，依次向后查找元素。

    增删元素快：都是只需要修改连接下个元素的地址即可。

    5）红黑树

    二叉树：binary tree，是每个结点不超过2的有序树。

    红黑树：本身就是一颗二叉查找树，将节点插入后，该树仍然是一颗二叉查找树。也就意味着，树的键值仍然是有序的。

    红黑树的约束：

    节点可以是红色的或者黑色的。 根节点是黑色的。叶子节点（特指空节点）是黑色的。每个红色节点的子节点都是黑色的。任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同。

    红黑树的特点：速度特别快，趋近平衡树，查找叶子元素最少和最多次数不多于二倍。

 2、List集合

 3、List的子类ArrayList集合

 4、Set接口

 5、Collections（集合工具类，用来对集合进行操作）

 （1）常用功能

   public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。

   public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。

   public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。

   public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

//采用默认的顺序      
        ArrayList<Integer> list = new ArrayList<Integer>();
          
          Collections.addAll(list, 1,6,5,100);
          Collections.sort(list);
          System.out.println(list);// [1, 5, 6, 100]
          
          ArrayList<String> str = new ArrayList<String>();
          Collections.addAll(str, "jdk","aa","bcd","ac");
          Collections.sort(str);
          System.out.println(str);//[aa, ac, bcd, jdk]

 （2）Comparator比较器

   public int compare(String 01,String o2)：比较两个参数的顺序。

   按升序排序，则o1<o2返回负数，o1>o2返回正数，相等返回0

   按降序排序，则o1>o2返回负数，o1<o2返回正数，相等返回0

ArrayList<String> str = new ArrayList<String>();
    str.add("cba");
    str.add("aba");
    str.add("sba");
    str.add("nba");
          
    Collections.sort(str,new Comparator<String>()){
        	   public int compare(String o1,String o2) {
        		   return o2.charAt(0)-o1.charAt(0);//比较字符串的第一个字母,按降序排序
        	   }
          });
    System.out.println(str);//[sba, nba, cba, aba]

（3）Comparable和Comparator两个接口的区别

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

四、Map

1、Map集合

Map中的集合，元素是成对存在的，每个元素由键与值两部分组成，且Map集合中不能包含重复的键，值可以重复，每个键只能对应一个值。

2、Map常用子类

HashMap：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。

LinkedHashMap：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构

3、Map接口中的常用方法

public V put(K key,V value):把指定的键与指定的值添加到Map集合中。

public V remove(Object key):把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。

public V get(Object key)根据指定的键，在Map集合中获取对应的值。

public Set<K>keySet():获取Map集合中所有的键，存储到Set集合中。

public Set<Map.Entry<K,V>>entrySet():获取到Map集合中所有的键值对对象的集合(Set集合)。

                HashMap<String,String> map = new HashMap<String,String>();
        	
        	map.put("aa","bb");
        	map.put("cc","dd");
        	map.put("aa","jj");
        	map.put("ee","dd");
        	
        	//键不能重复，值可以重复
        	System.out.println(map);//{aa=jj, cc=dd, ee=dd}
        	
        	System.out.println(map.get("aa"));//据指定的键，获取集合对应的值。

 注意：使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值

 4、Map集合遍历键找值

                HashMap<String,String> map = new HashMap<String,String>();
        	
        	map.put("aa","bb");
        	map.put("cc","dd");
        	map.put("ee","dd");
        	
        	Set<String> keys = map.keySet();//获取所有的键  获取键值
            for(String key :keys) {//key 就是键
            	String v = map.get(key);//获取对应值
            	System.out.println(key+"的cp:"+v);
            }

 5、Entry键值对对象（Entry将键值的对应关系封装成了对象）

  public K getKey()：获取Entry对象中的键。

  public v getValue()：获取Entry对象中的值。

在Map集合中也提供了获取所有Entry对象 public Set<Map.Entry<k,v>> entrySet()：获取到Map集合中所有的键值对对象的集合(Set集合)。

//Map集合遍历键值对方式         
                HashMap<String,String> map = new HashMap<String,String>();
        	
        	map.put("aa","bb");
        	map.put("cc","dd");
        	map.put("ee","dd");
        	
        	Set<Entry<String,String>> entrySet = map.entrySet();//获取所有的entry对象entrySet
        	
        	for(Entry<String,String> entry:entrySet) {//遍历的到每一个entry对象
        	  String key = entry.getKey();
        	  String value = entry.getValue();
        	  System.out.println(key+"的cp是："+value);
        	}
        	

 6、HashMap存储自定义类型键值

 7、LinkedHashMap

  保证元素迭代顺序：

                LinkedHashMap<String,String> map = new LinkedHashMap<String,String>();
        	map.put("aa","bb");
        	map.put("ee","dd");
        	map.put("cc","dd");
        	
        	Set<Entry<String,String>> entrySet = map.entrySet();//获取所有的entry对象entrySet
        	
        	for(Entry<String,String> entry:entrySet) {//遍历的到每一个entry对象
        	  String key = entry.getKey();
        	  String value = entry.getValue();
        	  System.out.println(key+"的cp是："+value);
        	}