集合、二叉树

/**
 * 
 */
package com.qfedu.Day17.HomeWork;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class HomeWork {
    @SuppressWarnings("rawtypes")
    public static void main(String[] args) {
      /*已知有一个工人Worker类 属性：姓名 年龄 工资， 行为 void work()
    a.在集合中添加三个工人对象，信息如下：
        zhang3  18   3000
        li4      25  3500
        wang5    22  3200
    b. 在li4之前插入一个工人 信息为： zhao6  24  3300
    c. 删除wang5的信息
    d. 利用for循环遍历，打印几个中所有工人的信息
    e. 利用迭代器遍历，对集合中的所有工人调用work方法
      */
        
        List list = new ArrayList();
        //a. list中的元素存储的是地址
        // 集合中只能存储对象-->引用的地址
        list.add(new Worker("zhang3",18,3000));
        list.add(new Worker("li4",25,3500));
        list.add(new Worker("wang5",22,3200));
        System.out.println(list);
        
        //b. 之所以集合可以存储任何数据类型--> 因为是父类Object
        //   向上转型 子类的引用赋值给了父类的对象  --> 只能调用父类的属性和方法,不能调用子类特有和方法
        for(int  i = 0; i<list.size();i++) {
            if(((Worker)(list.get(i))).getName().equals("li4")) {
                list.add(i, new Worker("zhao6",24,3000));
                break;
                
            }
        }
    
        System.out.println(list);
        //c.
        for(int i = 0;i<list.size();i++) {
            if(((Worker)(list.get(i))).getName().equals("wang5")) {
                list.remove(i);
                break;
                
            }
        }
        /*
         * ps不使用下标的形式: 传入一个王五的对象
         * 重写equals 和  hashcode
         * list.remove(new Worker("wang5",22,3200));
         */
        
        //d.
        for(Object obj : list) {
            System.out.println(obj);
        }
        
        //e.
        //1.获取迭代器对象
        Iterator it =  list.iterator();
        //遍历集合
        //2.判断迭代器中是否存在下一个元素 hasNext
         // 获取当前迭代器中对象next-->集合中的对象
        while(it.hasNext()) {
//            it.next();
//            it.next();
//            //一次循环移动两次  --> 一共就三个元素
            ((Worker)(it.next())).work();
        }
    
    }

}
/**
 * 
 */
package com.qfedu.Day17.HomeWork;

public class Worker {
    //对当前类进行描述  --> 对象的描述
    //类的作用 --> 用来存储描述对象的信息
    //姓名 年龄 工资， 行为 void work()
    //属性的:定义成员变量
    private String name;
    private int age;
    private int money;

    //构造方法时可以私有化 --> 单利 
    //                  --> 简单工厂  工具类
    
    //构造方法 --> 无参   -->有参 
    //提供了成员变量快捷的赋值方式
    public Worker() { //没有参数
        //super(); 调用父类的构造方法(无参)
        //这里还可以使用一些调用语句(方法的) 不这样做
        //初始化数组 ,集合初始化
        //给成员变量一些初始值(固定的)
        
    }
    public Worker(String name,int age,int money) {
        this.name = name;
        this.age = age;
        this.money = money;
        
    }
    
    
    
    //getter和setter方法 --> 对外提供访问和修改操作
    public String getName() { //获取当前成员变量
        return name;
    }
    public void setName(String name) {//修改当前成员变量
        this.name = name;      
        
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    
    
    
    //描述行为 --> 方法
    public void work() {
        System.out.println(name+"工人在工作拿到薪水:"+money);
    }
    
    
    /* 
     * 打印自定义对象的信息
     */
    @Override
    public String toString() {
        
        return name;
    }

}

/**
 * 
 */
package com.qfedu.Day17.HashSet;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

public class HashSetDemo {

    public static void main(String[] args) {
        //1.HashSet是Set接口的实现类
        //set是不允许存储重复值,排重 (排除重复)
        Set set = new  HashSet();
        // HashSet set = new Hash();
        //1.向集合中添加元素
        set.add("1");
        set.add("1");
        set.add("1");
        set.add("1");
        set.add("1");
        set.add("1");
        set.add("1");
        set.add("1");
        System.out.println(set);
        List list = new ArrayList();
        list.add("2");
        list.add("2");
        list.add("2");
        list.add("2");
        list.add("2");
        list.add("2");
        list.add("2");
        list.add("2");
        list.add("2");
        System.out.println(list);
        set.addAll(list);//存储的不是集合 是集合中元素
        System.out.println(set);
        
        //清空集合  内容清空 集合存在
        set.clear();
        //判断集合是否为空 -->空没有元素 true  反之false
        System.out.println(set.isEmpty());
        /*
         *  boolean contains(Object o) 
                 判断集合中是否存在指定元素 存在true 反之false
             boolean containsAll(Collection<?> c) 
              判读集合中是否存在指定集合中的元素 存在true 反之false 

         */
        
        //set同样支持Iterator迭代器
        //但是:它只支持标准的迭代器 不支持listIterator
        //千万不要在迭代器中使用集合自身的增加和删除方法
        //不然就会出现异常
        
        //1.获取迭代器对象
        Iterator it =  set.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        
        //set中删除只有一种直接删除方式
        //参数必须是一个对象
        //这个方法是有返回值的  true证明删除成功
        //                   false证明删除失败-->集合中没有这个对象
        set.remove("2");
        
        /*
         * 参考List
         * boolean removeAll(Collection<?> c) 
                           删除传入参数集合中元素 ,保留剩余元素
           boolean retainAll(Collection<?> c) 
                      保留传入参数集合中的元素,删除剩余元素 

         */
        //提供一个方法可以获得集合中所有元素的个数
        int size = set.size();
        //set集合除了Iterator迭代器方式可以遍历
        //同样支持for循环遍历 -->只支持增强for循环
        for(Object obj :set) {
            System.out.println(obj);
        }
        //ps:set并不支持使用循环的方式赋值
        //set集合可以转变为数组
          Object[] obj = set.toArray();
        //需求:如下set集合中存储了字符串1-9
          //    将集合转换为数组
          //    打印数组中值
        //    将数组中的值存到一个新的set集合中

    }

}

/**
 * 
 */
package com.qfedu.Day17.HashSet.SelfClass;

import java.util.HashSet;
import java.util.Set;

class Person{
    private String name;
    private int age;
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
    //认定两个对象是同一个对象
    //只要属性完全相同即可
    /* 
     */
    @Override
    public boolean equals(Object obj) {
        Person other = (Person)obj;
        return this.name.equals(other.name) && this.age == other.age;
    }
}

class A{
    
    @Override
    public boolean equals(Object obj) {
        
        return true;
    }
}
class B{
    
    @Override
    public int hashCode() {
    
        return 1;
    }
}
class C{
    
    @Override
    public boolean equals(Object obj) {
        
        return true;
    }
    @Override
    public int hashCode() {
    
        return 2;
    }
}





public class HashSetDemo2 {
    public static void main(String[] args) {
        Person p1 = new Person("小明", 18);
        Person p2 = new Person("小明", 18);
        System.out.println("若输出true证明当前对象和传入对象是同一个对象:"+p1.equals(p2));
        
        //创建一个Set集合
        Set set = new HashSet();
        set.add(new A());
        set.add(new A());
        set.add(new B());
        set.add(new B());
        set.add(new C());
        set.add(new C());
        set.add(p1);
        set.add(p2);
        //Set集合是自动排重 --> 排除重复
        System.out.println(set);

    }

}

/**
 * 
 */
package com.qfedu.Day17.TreeSet.Comparable;

public class Person implements Comparable{
       private int age;
       private int height;//

    public Person(int age,int height) {
        super();
        this.age = age;
        this.height = height;
    }

    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        
        return "年龄"+age+","+"身高"+height;
    }
    /* 
     * 是对对象需要排序的属性进行比较的方法
     */
    @Override
    public int compareTo(Object o) {
        Person other = (Person)o;
        
        //比较的是年龄 升序 必须满足 整数 负数和 零的关系
//        if(this.age > other.age) {
//            return 1; //正数 就是升序  负数是降序
//        }else if(this.age == other.age){
//            //继续书写 年龄相等身高降序
//            if(this.height > other.height) {
//                return -1;
//            }else if(this.height == other.height) {
//                //身高相等 , 体重升序
//                return 0;
//            }else {
//                return 1;
//            }
//    
//        }else {
//            return -1;
//        }
        //String 引用类型若需要排序,都会提供比较方法
//        String str1 = "abc";
//        String str2 = "ABC";
//        str1.compareTo(str2);
//        
        
        
        //用什么方式就可以得到正数,负数 或 零
        //需要升序就用当前对象的值 - 传入对象的值 升序
        //需要降序就用当前传入对象的值 - 当前对象的值 降序
        return this.age - other.age;
    
    }
 
}

/**
 * 
 */
package com.qfedu.Day17.TreeSet.Comparable;

import java.util.TreeSet;

public class PersonTest {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        set.add(new Person(10,180));
        set.add(new Person(17,190));
        set.add(new Person(12,150));
        set.add(new Person(12,170));
        set.add(new Person(9,165));
        set.add(new Person(20,155));
        System.out.println(set);

    }

}

/**
 * 
 */
package com.qfedu.Day17.TreeSet.Comparable;

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        //1.默认排序的 升序(从小到大)
        //2.排重 --> 排除重复
        //3.无序
        //4.TreeSet的底层实现是一个红黑二叉树(中序遍历 左 根 右)
        //ps:数据若需要排序就一定要具备可比性整数和整数   小数和小数   
        // 整数和字符串,自定义类的对象进行比较 不具备就会出现异常
        // 使用TreeSet就参考set集合的使用方式
        TreeSet set  =  new TreeSet();
        set.add(1);
        set.add(20);
        set.add(8);
        set.add(9);
        set.add("100");
        set.add(11);
        set.add(55);
        set.add(32);
        set.add(44);
        System.out.println(set);

    }

}

/**
 * 
 */
package com.qfedu.Day17.TreeSet.Comparator;

import java.util.Comparator;

public class GZ implements Comparator{

    /* 
     * 制定规则
     * 第一个参数是当前对象 --> this
     * 第二个参数是传入对象 --> other
     */
    @Override
    public int compare(Object o1, Object o2) {
        Person pthis = (Person)o1;
        Person pother = (Person)o2;
        
        return pthis.getAge() - pother.getAge();
    }

}
/**
 * 
 */
package com.qfedu.Day17.TreeSet.Comparator;

public class Person {
     private int age;

    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Person(int age) {
        super();
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
     
    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        
        return "年龄:"+age;
    }
    

}

/**
 * 
 */
package com.qfedu.Day17.TreeSet.Comparator;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.TreeSet;

public class TreeSetDemo {

    public static void main(String[] args) {
        //第一种方式
        //这才是使用自定义比较器(Comparator)的方式
          TreeSet set = new TreeSet(new GZ());
          set.add(new Person(18));
          set.add(new Person(11));
          set.add(new Person(14));
          set.add(new Person(20));
          set.add(new Person(16));
          set.add(new Person(19));
          System.out.println(set);
          
          
          //第二种方式 匿名内部类
          TreeSet set1 = new TreeSet(new Comparator() {

            @Override
            public int compare(Object o1, Object o2) {
                Person pthis = (Person)o1;
                Person pother = (Person)o2;
                
                return pthis.getAge() - pother.getAge();
            }
              
              
          });
          
          set1.add(new Person(18));
          set1.add(new Person(11));
          set1.add(new Person(14));
          set1.add(new Person(20));
          set1.add(new Person(16));
          set1.add(new Person(19));
          System.out.println(set1);
          
          
          //ps:
          Integer[] array = new Integer[10];
          for(int i = 0;i<array.length;i++) {
              array[i] = (int)(Math.random()*100);
          }
          //给当前数组排序 升序
          Arrays.sort(array);
          System.out.println(Arrays.toString(array));
          //需要降序 --> lambda表达式
          Arrays.sort(array, new Comparator() {

            @Override
            public int compare(Object o1, Object o2) {
                Integer ithis = (Integer)o1;
                Integer iother = (Integer)o2;
                return iother.compareTo(ithis);
            }
        });
          System.out.println(Arrays.toString(array));
    
    }

}