集合例题，面向对象-封装

package demo211129;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;

import org.junit.Test;

import java.util.Random;
import java.util.Set;
import java.util.TreeMap;

public class TestA {
	// 随机生成n个整数[0,k)
	// 输出出现次数最多的整数和相应的次数
	// 按次数排序后，输出数据和对应的次数

	public static void main(String[] args) {

	}

	// 最值
	@Test
	public void Start1() {
		// 1-随机
		HashMap<Integer, Integer> map = random(10, 5);
		System.out.println(map);
		// 2-最大次数---最大次数有可能不只一个
		int max = maxCount(map);
		System.out.println(max);
		// 3-输出
		print(map, max);
	}

	/**
	 * 
	 * @param n 随机的数据个数
	 * @param k 随机数据范围
	 * @return HashMap<Integer, Integer> key=数据，value=次数
	 */
	public HashMap<Integer, Integer> random(int n, int k) {
		// 定义一个集合
		HashMap<Integer, Integer> map = new HashMap<>();
		// 随机数输入
		Random random = new Random();
		// 输入集合
		for (int i = 0; i < n; i++) {
			// 输入数据
			int key = random.nextInt(k);
			// 从key得到value
			Integer value = map.get(key);
			// 判断key出现的次数，value为空即value=1，否则value++
			map.put(key, value == null ? 1 : value + 1);
		}
		// 返回集合
		return map;

	}

	/**
	 * 
	 * @param map 所判断的集合
	 * @return max 集合中出现次数最多的key的次数
	 */
	public int maxCount(HashMap<Integer, Integer> map) {
		int max = 0;
		for (Integer value : map.values()) {
			if (max < value)
				max = value;
		}
		return max;
	}

	/**
	 * 
	 * @param map
	 * @param max
	 */
	public void print(HashMap<Integer, Integer> map, int max) {
		// 遍历节点--map.entrySet()->节点的集合
		for (Entry<Integer, Integer> entry : map.entrySet()) {
			if (entry.getValue() == max)
				System.out.println(entry);
		}
	}
}

class TestTwo {
	public static void main(String[] args) {
		TestTwo tt = new TestTwo();
		tt.Start2();
	}

	public void Start2() {
		// 1.随机
		HashMap<Integer, Integer> map = random(10, 5);
		// 2.输出
		// 方法一
		sort1(map);
		// 方法二
		sort2(map);
	}

	public HashMap<Integer, Integer> random(int n, int k) {
		HashMap<Integer, Integer> map = new HashMap<>();
		Random random = new Random();
		for (int i = 0; i < n; i++) {
			int key = random.nextInt(k);
			Integer value = map.get(key);
			map.put(key, value == null ? 1 : value + 1);
		}

		return map;
	}

	// 方法一
	public void sort1(HashMap<Integer, Integer> map) {
		// map.entrySet()键值对的集合
		Set<Entry<Integer, Integer>> entry = map.entrySet();
		ArrayList<Entry<Integer, Integer>> list = new ArrayList<>();
		list.addAll(entry);
		int len = list.size();
		for (int i = 0; i < len - 1; i++) {
			for (int j = 0; j < len - 1 - i; j++) {
				// 索引值为j的节点、键值对
				Entry<Integer, Integer> left = list.get(j);
				Entry<Integer, Integer> right = list.get(j + 1);
				if (left.getValue() > right.getValue()) {
					list.set(j, right);
					list.set(j + 1, left);
				}
			}
		}
		System.out.println(list);
	}

	// 方法二
	public void sort2(HashMap<Integer, Integer> map) {
		// treeMap---->key次数，value数据
		TreeMap<Integer, HashSet<Integer>> treeMap = new TreeMap<>();
		for (Entry<Integer, Integer> entry : map.entrySet()) {
			Integer key = entry.getKey();// 数据
			Integer val = entry.getValue();// 次数
			// 如果treeMap中包含了次数
			if (treeMap.containsKey(val)) {
				// 把treeMaP中次数对应的数值存入value集合
				HashSet<Integer> value = treeMap.get(val);
				// value集合添加treeMap的数据
				value.add(key);
			} else {
				HashSet<Integer> value = new HashSet<>();
				value.add(key);
				treeMap.put(val, value);
			}
		}
		System.out.println(treeMap);
	}

}

---

---

package demo211129;

//面向对象-三大特征(提高代码整体的可复用性)

//封装=数据+对数据的操作
//继承
//多态
//(抽象)

//实体类=封装（事物）对象所定义的类
//将各种相关数据封装在一起，类的对象主要用于存储每个结构
//实体类=创建对项+存储功能
//实体类命名后缀：Model Entity Bean Pojo vo
//功能类
//工具类

public class TestB {

  

 private int number;
    private int id;

    // 实体类封装过程的组成部分
    // **1-私有的属性变量：首字母必须小写(变量名长度至少3个字符，除了id)
    // *2-公有的属性方法：getter/setter
    // 3-构造方法
    // 4-直接操作属性的其他方法

    // 封装的意义
    //1-隐藏类的实现细节
    //2-让使用者只能通过实现定制好的方法来访问数据，可以方便地加入控制逻辑
    //，限制对数据的不合法操作
    //3-便于修改，增强代码的可维护性
  

 public static void main(String[] args) {
        PersonModel p1=new PersonModel();
        //p1.test=100;
        
        TestB tb1 = new TestB(10, 20);
        TestB tb2 = new TestB();
        tb2.number=10;
        tb2.id=20;

        TestA1Model ta1 = new TestA1Model();
        // ta1.number;

        ta1.setNumber(100);
        int num = ta1.getNumber();
    }

    public TestB(int number, int id) {// 构造方法
        this.number = number;
        this.id = id;
    }

    public TestB() {
    }

    public void add() {
        id++;
    }

}
 

---

---

package demo211129;

public class PersonModel {
    
    //public int test
 自动生成get和set   
Source----->Generate Getters and Setters

get（）-------->获得属性值

set（）-------->给属性赋值

    /**
     * 
     * 身份证号
     */    
    private String id;
    private String name;
    private char gender;
    private int age;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>0)
        this.age = age;
    }

}

---

---

package demo211129;
 

public class TestA1Model {
    // 访问修饰符--私有的--所修饰的可以在当前范围（类体）内使用
    private int number;// 随机数据
    private int count;// 数据次数

    // get() 获取属性值
    public int getNumber() {
        return number;
    }

    // set() 给属性赋值
    public void setNumber(int number) {
        this.number = number;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

}

---

---

package demo211129;

import java.util.ArrayList;
import java.util.Random;

import org.junit.Test;

//随机生成n个整数（整数范围:[ 0,k )
//1-(最值）-输出出现次数最多的整数和相应的次数
//2-(排序)-按次数排序后,输出数据和对应次数

public class TestA1Demo {

    public static void main(String[] args) {

    }

    @Test
    public void start() {
        // 1-随机
        ArrayList<TestA1Model> list = random(10, 5);
        print(list);
        System.out.println("************");
        int max = max(list);
        printByMax(list, max);
        System.out.println("************");
        // 2-排序
        print(sort(list));

    }

    // 生成随机数组
    // -----------------
    public ArrayList<TestA1Model> random(int n, int k) {
        ArrayList<TestA1Model> list = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < n; i++) {
            int p = random.nextInt(k);
            if (!isExist(list, p)) {
                TestA1Model ta1 = new TestA1Model();
                ta1.setCount(1);
                ta1.setNumber(p);
                list.add(ta1);
            }
        }
        return list;
    }
    public boolean isExist(ArrayList<TestA1Model> list, int p) {
        for (TestA1Model model : list) {
            if (model.getNumber() == p) {
                model.setCount(model.getCount() + 1);
                return true;
            }
        }
        return false;
    }

    // 输出
    // ----------------------
    public void print(ArrayList<TestA1Model> list) {
        for (TestA1Model model : list) {
            System.out.println(model.getNumber() + " " + model.getCount());
        }
    }

    // 最值
    // ----------------------
    public int max(ArrayList<TestA1Model> list) {
        int max = 0;
        for (TestA1Model model : list) {
            if (model.getCount() > max) {
                max = model.getCount();
            }
        }
        return max;
    }

    public void printByMax(ArrayList<TestA1Model> list, int max) {
        for (TestA1Model model : list) {
            if (model.getCount() == max) {
                System.out.println("-------------");
                System.out.println(model.getNumber() + " " + model.getCount());
            }
        }
    }

    // 排序
    // ----------------------------
    public ArrayList<TestA1Model> sort(ArrayList<TestA1Model> list) {
        int len = list.size();
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                TestA1Model m1 = list.get(j);
                TestA1Model m2 = list.get(j + 1);
                if (m1.getCount() > m2.getCount()) {
                    list.set(j, m2);
                    list.set(j + 1, m1);
                }
            }
        }
        return list;
    }
}