java数据类型

1.字节类型

byte，字节【1字节】表示范围：-128 ~ 127 即：-2^7 ~ 2^7 -1
单纯的字节类型，一般就是用来表示数字。

public class Demo {
    public static void main(String[] args) {
        byte v1 = 99;
        byte v2 = 1;

        byte v3 = (byte) (v1 + v2);
        System.out.println(v3);
        System.out.println(Integer.toBinaryString(v1));
        System.out.println(Integer.toHexString(v1));

        int n1 = Integer.parseInt("b",16);
        System.out.println(n1);
    }
}

2.整数类型

byte，字节【1字节】表示范围：-128 ~ 127 即：-2^7 ~ 2^7 -1
short，短整型【2字节】表示范围：-32768 ~ 32767
int，整型【4字节】表示范围：-2147483648 ~ 2147483647
long，长整型【8字节】表示范围：-9223372036854775808 ~ 9223372036854775807

public class Hello {

    public static void main(String[] args) {
        byte v1 = 32;
        short v2 = 10000;
        int v3 = 22221331;
        long v4 = 554534353424L;
    }
}

3.字符

字符串是由多个字符串组成

char v1 = 'x';
char v2 = 'y';

String = "某某某";

4.字符串

定义字符串：

import java.io.UnsupportedEncodingException;

public class Hello {

    public static void main(String[] args) throws UnsupportedEncodingException {
        
        String v1 = "胡歌";
        String v2 = new String("杭州"); 

        String v4 = new String(new byte[]{-26, -83, -90, -26, -78, -101, -23, -67, -112});
        String v5 = new String(new byte[]{-50, -28, -59, -26, -58, -21}, "GBK");
        
        String v6 = new String(  new char[]{'彭', '于', '晏'}   ) ;
    }
}

字符串中的方法：

public class Hello {

    public static void main(String[] args) {
        String origin = "a苹果用户el";

        char v1 = origin.charAt(5); // 指定字符
        int len = origin.length();  // 长度
        for (int i = 0; i < len; i++) {
            char item = origin.charAt(i);
        }

        String v2 = origin.trim(); // 去除空白
        String v3 = origin.toLowerCase(); // 小写
        String v4 = origin.toUpperCase(); // 大写
        String[] v5 = origin.split("用"); // 分割 {""}
        String v6 = origin.replace("户", "胡"); // 替换
        String v7 = origin.substring(0, 2);  // 子字符串=切片 [0:2]
      
        
        boolean v9 = origin.contains("el");
        boolean v10 = origin.startsWith("a");
        String v11 = origin.concat("哈哈哈");
    }
}

5.数组

存放固定长度的元素

import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // [123,1,99]
        int[] numArray = new int[3];
        numArray[0] = 123;
        numArray[1] = "xxx";
        numArray[2] = 99;
        System.out.println(Arrays.toString(numArray));

        String[] names = new String[]{"daring", "alex", "eric"};
        System.out.println(Arrays.toString(names));
        

        String[] nameArray = {"daring", "alex", "eric"};
        System.out.println(Arrays.toString(nameArray));

        // nameArray[0]
        // nameArray.length
        for (int idx = 0; idx < nameArray.length; idx++) {
            String item = nameArray[idx];
        }

    }
}

6.关于Object

在Python中每个类都默认继承Object类（所有的类都是Object的子类）。
在Java所有的类都是默认继承Object类。

import sun.lwawt.macosx.CSystemTray;

import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // String v1 = "杭州";
        Object v1 = new String("杭州");
        System.out.println(v1);
        System.out.println(v1.getClass());

        Object v2 = 123;
        System.out.println(v2);
        System.out.println(v2.getClass());
    }
}

7.List系列

类似于Python中的列表

List是一个接口，接口下面有两个常见的类型（目的是可以存放动态的多个数据）

ArrayList，连续的内存地址的存储（内部自动扩容）。 -> Python列表的特点
LinkedList，底层基于链表实现（自行车链条）。 -> Python列表的特点

Java中接口，是用来约束实现他的类，约束他里面的成员必须有xx。

interface List{
    public void add(Object data);   // 接口中的方法，不写具体的实现，只用于约束。
}

// 类ArrayList实现了接口List，此时这个类就必须有一个add方法。
class ArrayList implements List{
    public void add(Object data){
         // 将数据data按照连续存储的方法放在内存。
        // ..
    }
}

// 类LinkedList实现了接口List，此时这个类就必须有一个add方法。
class LinkedList implements List{
    public void add(Object data){
         // 将数据data按照链表的形式存储
        // ..
    }
}

ArrayList示例：

import java.util.ArrayList;
import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        
        // ArrayList，默认内部存放的是混合数据类型。
        
        // ArrayList<String> data = new ArrayList<String>();
        // ArrayList<Object> data = new ArrayList<Object>();
        
        ArrayList data = new ArrayList();
        data.add("武沛齐");
        data.add("alex");
        data.add(666);
        data.add("tony");
        
        
        String value = data.get(1);
        // String value = (String) data.get(1);
        
        
        Object temp = data.get(1);
        String value = (String) temp; // 转化可转换的数据
            
        System.out.println(value);

        int xo = (int) data.get(2);
        System.out.println(xo);

        data.set(0, "哈哈哈哈");
        System.out.println(data);

        data.remove("eric");
        data.remove(0);
        System.out.println(data);

        int size = data.size();
        System.out.println(size);

        boolean exists = data.contains("武沛齐");
        System.out.println(exists);


        for (Object item : data) {
            System.out.println(item);
        }

        for (int i = 0; i < data.size(); i++) {
            Object item = data.get(i);
            System.out.println(item);
        }
    }
}

LinkedList示例：

import java.util.LinkedList;

public class Hello {

    public static void main(String[] args) {
        // [11,22,33,4]
        LinkedList<Integer> v1 = new LinkedList<Integer>();
        v1.add(11);
        v1.add(22);

        LinkedList v2 = new LinkedList();
        v2.add("上海");
        v2.add("大北京");
        v2.add(666);
        v2.add(123);

        //v2.remove(1);
        //v2.remove("路飞");

        v2.set(2, "杭州");
        v2.push("哈哈哈");
        // v2.addFirst(11);


        for (int i = 0; i < v2.size(); i++) {
            Object item = v2.get(i);
            System.out.println(item);
        }

        for (Object item : v2) {
            System.out.println(item);
        }
    }
}

关于迭代器：

import java.util.*;

public class Hello {

    public static void main(String[] args) {

        ArrayList s1 = new ArrayList();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");


        Iterator it = s1.iterator(); // 迭代器
        while (it.hasNext()) {
            String item = (String) it.next();
            System.out.println(item);
        }
    }
}

8.Set系列

Set是一个接口，常见实现这个接口的有两个类，用于实现不重复的多元素集合。

HashSet，去重，无序。
TreeSet，去重，内部默认排序（ascii、unicode）【不同的数据类型，无法进行比较】。

import java.util.*;

public class Hello {

    public static void main(String[] args) {
        // HashSet s1 = new HashSet();
        // Set s1 = new HashSet();
        // HashSet<String> s1 = new HashSet<String>();
        HashSet s1 = new HashSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");
        s1.add("P站");
        s1.add(666);
        System.out.println(s1); // [B站, A站, P站,666]
        
        // s2 = {"东京热","东北热","南京热"}
        HashSet s2 = new HashSet(){
            {
                add("东京热");
                add("东北热");
                add("南京热");
            }
        };
        System.out.println(s2);



        // Set s2 = new TreeSet();
        // TreeSet<String> s2 = new TreeSet<String>();
        TreeSet s3 = new TreeSet();
        s3.add("P站");
        s3.add("B站");
        s3.add("A站");
        s3.add("P站");
        // s3.add(666); //不可以

        System.out.println(s3); // [B站, A站, P站]

        TreeSet s4 = new TreeSet(){
            {
                add("P站");
                add("B站");
                add("A站");
                add("P站");
            }
        };
        System.out.println(s4); // [B站, A站, P站]

    }
}

9.Map系列

Map是一个接口，常见实现这个接口的有两个类，用于存储键值对。

HashMap，无序。

import java.util.*;

public class Hello {

    public static void main(String[] args) {
        HashMap h1 = new HashMap();
        h1.put("name","alex");
        h1.put("age",18);
        h1.put("hobby","男");
        System.out.println(h1); // {gender=男, name=alex, age=18}

        HashMap<String,String> h2 = new HashMap<String,String>();
        h2.put("name","alex");
        h2.put("age","18");
        h2.put("hobby","男");
        System.out.println(h2); // {gender=男, name=alex, age=18}

    }
}

TreeMap，默认根据key排序。（常用）

import java.util.*;

public class Hello {

    public static void main(String[] args) {
        TreeMap h1 = new TreeMap(); // 改为了TreeMap
        h1.put("name","alex");
        h1.put("age",18);
        h1.put("hobby","男");
        System.out.println(h1); // {age=18, hobby=男, name=alex}

        TreeMap<String,String> h2 = new TreeMap<String,String>();
        h2.put("name","alex");
        h2.put("age","18");
        h2.put("hobby","男");
        System.out.println(h2); // {age=18, hobby=男, name=alex}

        Map h4 = new TreeMap();
        h4.put("name","alex");
        h4.put("age",18);
        h4.put("hobby","男");
        System.out.println(h4); // {age=18, hobby=男, name=alex}
    }
}

常见操作：

import java.util.*;

public class Hello {

    public static void main(String[] args) {
        TreeMap h1 = new TreeMap(); // 改为了TreeMap
        h1.put("name", "alex");
        h1.put("age", "18");
        h1.put("hobby", "男");
        h1.put("hobby", "女人");

        h1.remove("age");
        int size = h1.size();

        Object value = h1.get("name"); // 不存在，返回null
        System.out.println(value);

        boolean existsKey = h1.containsKey("age");
        boolean existsValue = h1.containsValue("alex");

        h1.replace("name", "李杰");
        System.out.println(h1);


        // 循环: 示例1
        // {  ("name", "alex")，("age", "18"),  }
        Set<Map.Entry<String, String>> s1 = h1.entrySet();
        Iterator it1 = s1.iterator();
        while (it1.hasNext()) {
            // ("name", "alex")
            Map.Entry<String, String> entry = (Map.Entry<String, String>) it1.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
        }

        // 循环: 示例2
        Set s2 = h1.entrySet();
        Iterator it2 = s2.iterator();
        while (it2.hasNext()) {
            Map.Entry entry = (Map.Entry) it2.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
        }

        // 循环: 示例3
        TreeMap<String, String> h2 = new TreeMap<String, String>(); // 改为了TreeMap
        h2.put("name", "alex");
        h2.put("age", "18");
        for (Map.Entry<String, String> entry : h2.entrySet()) {
            String k = entry.getKey();
            String v = entry.getValue();
        }

        // 循环: 示例4
        TreeMap h3 = new TreeMap(); // 改为了TreeMap
        h3.put("name", "alex");
        h3.put("age", 18);
        
        for (Object entry : h3.entrySet()) {
            Map.Entry<String, Object> entryMap = (Map.Entry<String, Object>) entry;
            String k = entryMap.getKey();
            Object v = entryMap.getValue(); // 18   "alex"
            
            if (v instanceof Integer) {
                System.out.println("数字：" + Integer.toString((Integer) v));
            } else if (v instanceof String) {
                System.out.println("字符串：" + (String) v);
            } else {
                System.out.println("未知类型：" + v.toString());
            }
        }
    }
}

posted @ 2023-07-02 23:07 小青年て阅读(12) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部