Java基础知识扫盲点（二）

最新推荐文章于 2021-02-28 01:18:58 发布

sglwh1234

最新推荐文章于 2021-02-28 01:18:58 发布

阅读量365

点赞数

分类专栏： java-基础知识文章标签： java

本文链接：https://blog.youkuaiyun.com/sglwh1234/article/details/78583927

版权

java-基础知识专栏收录该内容

29 篇文章

订阅专栏

接上一文

集合框架
List存取数据
Map存取数据
Iterator遍历集合
Collection类操作集合
泛型
泛型集合存取和操作数据
集合框架
因数组是固定长度，所以我们需要集合框架。
虚线框是接口，实线框是类。

Collection接口存储一组不唯一的，无序的对象。
List 接口存储一组不唯一的，有序的对象。
Set接口存储一组唯一的，无序的对象。
Map接口存储一组键值对对象，提供key 到value的映射。
Collections 类是一个工具类。

List 分为 ArrayList 和LinkedList 。
ArrayList 实现了长度可变的数组，在内存中分配连续的内存空间。遍历元素和随机访问元素的效率比较高。

LinkedList 采用链表存储方式，插入和删除元素时效率比较高。
List常用方法
获得长度： .size(),
根据下标获得对象： .get(i),

ArrayList常用方法

Clear清空集合，isEmpty()判断是否为空， iterator()迭代， toArr
ay()

Linked常用方法

Set接口
Set接口存储一组唯一，无序的对象
HashSet是Set接口常用的实现类

Set接口如何判断加入对象是否存在？
答案：采用对象的equals（）方法比较两个对象是否相等。即判断两个对象的内存地址是否相等。

如何遍历Set集合
方法1：通过Iterator 实现遍历
步骤：获取Iterator ： Collection 接口的 iterate(）方法
Iterator的方法
a. boolean hasNext() 判断是否存在另一个可访问的元素。
b. Object next()

方法2：直接使用Iterator
Iterator iterator = news.iterator();
while(iterator.hasNext()){
iterator.next();
}

Map（ hashMap 或treeMap）方法参考API帮助文档
可以通过Map的put方法来建立缓存。

通过Map来建立缓存

package com.lwh.util;
import java.util.HashMap;

import java.util.Map;



public class CachFactory {
    private static CachFactory cachFactory = null;



    // 缓存已经创建的Map对象

    private Map<String, Map<String, Object>> factoryMap = new HashMap<String, Map<String, Object>>();



    // 单例模式

    private CachFactory() {

    }



    // 使用单例模式

    public static CachFactory getInstance() {

        if (cachFactory == null) {

            cachFactory = new CachFactory();

        }

        return cachFactory;

    }



    /**

     * 创建key为cachName的Map对象

     * 

     * @param cachName

     * @return

     */

    public Map<String, Object> createCache(String cachName) {

        Map<String, Object> map = new HashMap<String, Object>();

        factoryMap.put(cachName, map);

        return map;

    }



    /**

     * 判断是否存在key为cachName的map

     * 

     * @param cachName

     * @return

     */

    public boolean isExist(String cachName) {

        if (factoryMap.containsKey(cachName)) {

            return true;

        }

        return false;

    }



    /**

     * 获取key为cachName的map对象

     * 

     * @param cachName

     * @return

     */

    public Map<String, Object> getMapByKey(String cachName) {

        if (factoryMap.containsKey(cachName)) {

            return factoryMap.get(cachName);

        }

        return null;

    }
}

Map接口专门处理键值对映射数据的存储，可以根据键实现对值的操作
最常用的实现类是HashMap();

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class CacheFactory {

    public static void main(String[] args) {
        Map<String,String> countries = new HashMap<String,String>();
        countries.put("cn", "China");
        countries.put("us", "America");
        String  getValueByKey =(String) countries.get("china");
        int  countriesNumber =  countries.size();
        if(countries.containsKey("us")){
            System.out.println("国家中包含us,值为"+ countries.get("us"));
        }

        System.out.println("删除掉us前，countries中有如下数据");
        System.out.println("建:"+  countries.keySet());
        System.out.println("值: "+countries.values());
        for( Entry<String, String> c : countries.entrySet()){
            System.out.println("key: "+ c.getKey() + ", value: " + c.getValue());
        }


        if(countries.containsKey("us")){
            System.out.println("国家中包含us,值为"+ countries.get("us"));
        }

        countries.remove("us");
        System.out.println("删除掉us后，countries中有如下数据");
        System.out.println("建:"+  countries.keySet());
        System.out.println("值: "+countries.values());
        for( Entry<String, String> c : countries.entrySet()){
            System.out.println("key: "+ c.getKey() + ", value: " + c.getValue());
        }


    }   

}

遍历Map方法

public static void main(String[] args) {


  Map<String, String> map = new HashMap<String, String>();
  map.put("1", "value1");
  map.put("2", "value2");
  map.put("3", "value3");

  //第一种：普遍使用，二次取值
  System.out.println("通过Map.keySet遍历key和value：");
  for (String key : map.keySet()) {
   System.out.println("key= "+ key + " and value= " + map.get(key));
  }

  //第二种
  System.out.println("通过Map.entrySet使用iterator遍历key和value：");
  Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
  while (it.hasNext()) {
   Map.Entry<String, String> entry = it.next();
   System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
  }

  //第三种：推荐，尤其是容量大时
  System.out.println("通过Map.entrySet遍历key和value");
  for (Map.Entry<String, String> entry : map.entrySet()) {
   System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
  }

  //第四种
  System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
  for (String v : map.values()) {
   System.out.println("value= " + v);
  }
 }

泛型：本质上是参数化类型，是将对象的类型作为参数，指定到其他类或者方法上，从而保证类型转换的安全性和稳定性。（如 List或Map 的get（）方法获得的对象类型有可能是String，int 或其他的不确定性，但参数化类型后就可以把对象的类型局限在定义好的类型上）
泛型的好处：
本质上是参数化类型，
泛型集合可以约束集合内的元素类型
典型的泛型集合有ArrayList, HashMap

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public  class Student implements Comparable {

    private String stuName;
    private int ranking;



    public Student(String stuName, int ranking) {
        super();
        this.stuName = stuName;
        this.ranking = ranking;
    }



    @Override
    public int compareTo(Object o) {
        Student s = (Student) o;
        return this.ranking - s.ranking;
    }


    //可以把上面的compareTo()方法改成如下

    public int compareTo(Object o){
        Student s = (Student) o;
        if(this.ranking==s.ranking)
            return 0;
        else if(this.ranking > s.ranking)
            return 1;
        else 
        return -1;

    }


    @Override
    public String toString() {
        return "Student [stuName=" + stuName + ", ranking=" + ranking + "]";
    }



    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        List<Student>  arre = new ArrayList<Student>();
        arre.add(new Student("jack",10));
        arre.add(new Student("Bill",23));
        arre.add(new Student("Rudy",7));
        System.out.println(arre);
        Collections.sort(arre);
        System.out.println(arre);
    }
}

Collection是集合接口

枚举（枚举类型定义变量时，当给变量赋值时，赋值条件受枚举类型限制）
枚举有一组固定的常量组成的类型

包装类:包装类把基本类型数据转换成对象
包装类的作用：
a.提供一些有用的方法
b. 集合里面存放都是对象，不能存放基本类型的数据，必须把基本数据类型包装成包装类方可存放。

Object 类可分为三大类：Boolean,Character,Number.
Number 可以分为以下多个类：Byte，Short，Integer，Long,Float,Double.

Boolean 对应 boolean
Byte 对应 byte
Character 对应 char
Double 对应 double;
Float 对应 floate ;
Long 对应 long;
Integer 对应 int;

包装类构造实例
1）构造方法：所有包装类都可以将与之对应的基本数据类型作为参数，来构造他们的实例
public Type (type, value); 如： Integer i = new Integer(1);

2)除Character 类外，其他包装类可将一个字符串作为参数构造他们的实例
pulic Type (String vaule) 如： Integer i = new Integer（“123”）；

XXXValue（）：将包装类转化为基本数据类型。
如： Integer integerId= new Integer(25);
int intId = integerId.intValue();
Integer integerId = new Integer(25); System.out.println(integerId.byteValue());; System.out.println(integerId.intValue()); System.out.println(integerId.doubleValue()); System.out.println(integerId.floatValue()); System.out.println(integerId.longValue()); System.out.println(integerId.shortValue());

valueOf():
所有包装类都有如下方法：
public static Type valueOf(type value)
如： Integer intValue = Integer.valueOf(21);
除Character外，其他包装类都有如下方法：
public static Type valueOf(String value);
如： Integer intValue = Integer.valueOf(“21”);

parseXX(): 字符串转为基本数据类型(Character除外）。
int num = Integer.parseInt(“39“）
boolean bool =Boolean.parseInt(“true”);

装箱：基本数据类型转为包装类的对象的过程。
拆箱：包装类对象转为基本数据类型的过程。

JavaDoc： Project>javadoc generation

Math: java.lang.Math 提供了常用的数学运算方法和两个静态常量E（对数的底数）和PI（圆周率）
Math.abs(-34); 求绝对值
Math.max(3,6); 求最大值
int ran = (int)(Math.random()*10) ；生成0-9之间的随机数。

Random
JAVA学习笔记:随机数(Math类和Random类生成的随机数)
http://blog.youkuaiyun.com/qq_22195761/article/details/70313837

//      Random ran = new Random();
//       
//        // create byte array
//        byte[] nbyte = new byte[30];
//        
//        // put the next byte in the array
//        ran.nextBytes(nbyte);
//     
//        // check the value of array   
//        System.out.println("Value of byte array: " + nbyte);
//
//      System.out.println("产生一个随机Gaussian:"+ran.nextGaussian());
//      System.out.println("产生一个随机Boolean:"+ran.nextBoolean());
//      System.out.println("产生一个随机整数:"+ran.nextInt());
//      System.out.println("产生一个随机整数:"+ran.nextInt(10));
//      System.out.println("产生一个随机整数:"+ran.nextLong());
//      System.out.println("产生一个随机整数:"+ran.nextDouble());
//      System.out.println("产生一个随机整数:"+ran.nextFloat());
//

相同种子数的Random对象，相同次数生成的随机数字是完全相同的

Random r1 = new Random(10);
        Random r2 = new Random(10);
        for(int i = 0;i < 2;i++){
            System.out.println(r1.nextInt());
            System.out.println(r2.nextInt());
        }

使用String对象存储字符串
String s = “hello world”;
String s= new String();
String s = new String (“hello world”);

String length()方法，equals()方法，equalsIgnoreCase(); toLowerCase()方法， toUppderCase()方法

“==” 和“equals（）”区别
“==”判断两个字符串在内存中的地址，即判断是否是同一个字符串对象。

比较：
String s1=”java”,
String s2=”java”.
所以s1==s2是true。s1和s2是同一个对象。所有内容都会存放在虚拟的字符串池。
若String s3=new String(“java”)
所以s1==s3是false. 但s1.equals.s3

字符串连接 concact()
如： String a =”abc”;
a.concat(“efg”);

字符串常用方法：
public int indexOf(int ch) ：搜索第一个出现的字符“ch”,如果没找到返回-1.
public int indexOf(String s）：搜索第一个出现的字符串“s”,如果没找到返回-1.
public int lastIndexOf(int ch) ：搜索第一个出现的字符“ch”,如果没找到返回-1.
public int ilstIndexOf(String s）：搜索第一个出现的字符串“s”,如果没找到返回-1.

public String substring(int index): 截取从位置索引开始的字符串部分。
public String substring (int beginindex, int endindex) :提前beginindex到 endindex 之间的字符串部分。
public String trim(): 去掉前后空格后所剩下的字符串。

public String [] split(String regex)

    String info= "床前明月光 疑是地上霜 举头望明月 低头思故乡";
        String []  stringArray=info.split(" ");
        for(String s:stringArray){
            System.out.println(s);
        }

StringBuffer 类
对字符串频繁修改（如字符串连接等），使用StringBuffer可以提高效率
StringBuffer 申明：
StringBuffer strb = new StringBuffer()
StringBuffer strb = new StringBufffer(“aaa”);
StringBuffer 常用方法：
strb.toString();
strb.append(); 追加字符串
strb.insert(1,”xx”); 在index为1 处插入“xx”,这里的“xx”代表任何基本数据类型

StringBuffer s = new StringBuffer("aaaa");
        s.append("bbbb");
        s.insert(2, "cccc");
        System.out.println(s);

日期格式

Date date = new Date();
        SimpleDateFormat formater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
        String now = formater.format(date);
        System.out.println(now);
        SimpleDateFormat formater2 = new SimpleDateFormat("yy-MM-dd HH:mm:ss"); 
        String now2 = formater2.format(date);
        System.out.println(now2);

Calendar 类：用于设置和捕获日期/时间数据的特定部分。

常用属性和方法：
int get(int field): 返回给定日历字段的值。
MAY_OF_MONTH; 一个月中的某天个DAY_OF_WEEK; 一周中的某天

中的某天

Calendar是抽象类，抽象类不能实例化。所以要操作Calendar时，getInstance() 使用默认时

获得一个日历   // 获取年
         int year = calendar.get(Calendar.YEAR);
21 
22         // 获取月，这里需要需要月份的范围为0~11，因此获取月份的时候需要+1才是当前月份值
23         int month = calendar.get(Calendar.MONTH) + 1;
24 
25         // 获取日
26         int day = calendar.get(Calendar.DAY_OF_MONTH);
27 
28         // 获取时
29         int hour = calendar.get(Calendar.HOUR);
30         // int hour = calendar.get(Calendar.HOUR_OF_DAY); // 24小时表示
31 
32         // 获取分
33         int minute = calendar.get(Calendar.MINUTE);
34 
35         // 获取秒
36         int second = calendar.get(Calendar.SECOND);
37 
38         // 星期，英语国家星期从星期日开始计算
39         int weekday = calendar.get(Calendar.DAY_OF_WEEK);
40 
41         System.out.println("现在是" + year + "年" + month + "月" + day + "日" + hour
42                 + "时" + minute + "分" + second + "秒" + "星期" + weekday);
43     }
44