Java基础知识扫盲点（二）

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

sglwh1234

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

阅读量316

点赞数

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

本文链接：https://blog.csdn.net/sglwh1234/article/details/78583927

版权

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

29 篇文章 1 订阅

订阅专栏

接上一文

集合框架
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.csdn.net/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

sglwh1234

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础知识扫盲点（二）

接上一文集合框架List存取数据Map存取数据Iterator遍历集合Collection类操作集合泛型泛型集合存取和操作数据集合框架因数组是固定长度，所以我们需要集合框架。虚线框是接口，实线框是类。 Collection接口存储一组不唯一的，无序的对象。 List 接口存储一组不唯一的，有序的对象。 Set接口存储一组唯一的，无序的对象。 Map接口存储一组键值
复制链接

扫一扫