第十七笔记

黑马程序员  <a href="http://www.itheima.com" target="blank">java培训</a>

                      第十七天笔记

1.集合嵌套存储和遍历元素的案例代码实现

package lm.list;

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

public class DoubleList {
public static void main(String[] args) {
// 第一个班级的学生
List<String> first = new ArrayList<String>();
first.add("张三");
first.add("李四");
first.add("王五");
first.add("李二");

// 第二个班级的学生
List<String> second = new ArrayList<String>();
second.add("tom");
second.add("fox");
second.add("cindy");
second.add("candy");

//嵌套循環
List<List<String>> school=new ArrayList<List<String>>();
school.add(first);
school.add(second);

for(List<String> s:school)
{
for(String ss:s)
{
System.out.println(s);
}
}
}

}

 

2.Arraylist集合的toString方法源码解析

注意：使用打印语句打印对象的时候，系统会默认调用ToString方法。其TOString方法一定要重写。

//介绍一下关于ArrayList的toString();
public class ListDemo3 {

    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");

        // 当我们使用打印语句打印对象时，会默认调用其toString方法
        System.out.println(list);  //[hello, world, java]
        //通过结果可以知道，其toString方法一定重写。
        //我们在ArrayList类中没有看到toString方法，那么去其父类中查找.

 

3.用户登录案例

package lm.dao;

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

import lm.entity.Student;

public class Userdao {

    public List<Student> list = new ArrayList<Student>();

    public void regist(Student sc) {
        for (Student student : list) {
            if (sc.getName().equals(student.getName())) {
                System.out.println("注册失败，已存在用户名");
                return;
            }
        }
        list.add(sc);
        System.out.println(list);
        System.out.println("注册成功");

    }

    public Boolean login(Student sc) {
        for (Student student : list) {
            if (sc.getName().equals(student.getName())) {
                return true;
            }
        }
        return false;

    }
    
  public Student login1(Student sc)    
  {
      for (Student student : list) {
            if (sc.getName().equals(student.getName())) {
                 sc.setName(student.getName());
                 sc.setSex(student.getSex());
                 sc.setAge(student.getAge());
                 sc.setMoney(student.getMoney());
                 return sc;
            }
        }
    return sc;
  }
  
}

package lm.entity;

public class Student {
   private String name;
   private String sex;
   private int age;
   private double money=0;
  public Student() {
    
        
    }   
public Student(String name, String sex, int age) {
    super();
    this.name = name;
    this.sex = sex;
    this.age = age;
}
public String getName() {
    return name;
}
public double getMoney() {
    return money;
}
public void setMoney(double money) {
    this.money = money;
}
public void setName(String name) {
    this.name = name;
}
public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
public Double saveMoney(Double money)
{
    return this.money+money;
    }
public Double getMoney(Double money)
{
    return this.money-money;
    }

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    result = prime * result + ((sex == null) ? 0 : sex.hashCode());
    return result;
}
@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Student other = (Student) obj;
    if (age != other.age)
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    if (sex == null) {
        if (other.sex != null)
            return false;
    } else if (!sex.equals(other.sex))
        return false;
    return true;
}
@Override
public String toString() {
    return "Student [name=" + name + ", sex=" + sex + ", age=" + age
            + ", money=" + money + "]";
}

}

package lm.opmoney;

import java.util.Scanner;

import lm.entity.Student;

public class Opmoney {
    Scanner sc=new Scanner(System.in);
    Student s=new Student();
    public Opmoney(Student sc)
    {
        s=sc;
        System.out.println("接受到的用户是"+s);
    }
    public void show()
    {
        while(true){
        System.out.println("选择你要进行的操作");
        System.out.println("1.存款");
        System.out.println("2.取款");
        System.out.println("3.查询用户信息");
        System.out.println("4.返回上一级");
        
        int a = sc.nextInt();
        switch (a) {
        case 1:
           saveMoney();
            break;
        case 2:
           getMoney();
            break;
        case 3:
           getMessage();
            break;
        case 4:
                return;
        default:
            System.out.println("输入错误");
            break;
        }
        }
    }
    private void getMessage() {
        System.out.println(s);
        
    }
    private void getMoney() {
        System.out.println("请输入你要取出的金额");
        double money=sc.nextDouble();
        s.setMoney(    s.getMoney(money));
    }
    private void saveMoney() {
        System.out.println("请输入你要存入的金额");
        double money=sc.nextDouble();
        s.setMoney(    s.saveMoney(money));
    
        
    }
}

package lm.view;

import java.util.Scanner;

import lm.dao.Userdao;
import lm.entity.Student;
import lm.opmoney.Opmoney;

public class InitFrame {
    Scanner sc = new Scanner(System.in);
    Userdao userdao=new Userdao();
    public InitFrame() {
        while(true){
        System.out.println("请选择操作：1.注册\t  2.登录\t 3.退出\t  ");
        int a = sc.nextInt();
        switch (a) {
        case 1:
            registFrame();
            break;
        case 2:
           loginFrame();
            break;
        case 3:

            break;
        default:
            System.out.println("输入错误");
            break;
        }
        }

    }

    private void registFrame() {
        System.out.println("请输入你的姓名");
        String name=sc.next();
        System.out.println("请输入你的性别");
        String sex=sc.next();
        System.out.println("请输入你的年龄");
        int age=sc.nextInt();
        Student st=new Student(name,sex,age);
        
        userdao.regist(st);
        
        
        
    }

    private void loginFrame() {
        System.out.println("请输入你的姓名");
        String name=sc.next();
        Student sc1=new  Student();
        sc1.setName(name);
        Boolean flag=  userdao.login(sc1);
        if(flag)
        {
            System.out.println("登陆成功");
            Student s=userdao.login1(sc1);
            Opmoney op=new Opmoney(sc1);
            System.out.println("传入的用户是"+sc1);
            op.show();
            
        }else
            
        {
            System.out.println("登陆失败，用户名不存在");
        }
        
        }
     
}

package lm.test;

import lm.view.InitFrame;

public class TestDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        InitFrame init=new InitFrame();
    }

}

 

4.Set集合概述及特点

Set集合的特点：无顺序不可以重复

注意：我们学习set，它没有特殊的方法，也就是说我们学习的都是从collection中的方法。主要学习数据结构。

 

5. HashSet  存储字符并遍历

  1.hashset中的元素是不重复的

  2.hashset中的元素是无顺序的（装入顺序和迭代的顺序不一致，并且不保证元素的顺序永远不变）

  3.hashset集合怎样使用

public class HashSetDemo1 {

    public static void main(String[] args) {
        // 1.创建一个HashSet集合.
        HashSet<String> set = new HashSet<String>();
        // 2.向集合中添加字符串元素
        System.out.println(set.add("tom")); //true
        System.out.println(set.add("james")); //true
        System.out.println(set.add("fox")); //true
        //System.out.println(set.add("james")); //false
        
        set.add("a");
        //3.遍历set集合  迭代器
        // for(Iterator<String> it=set.iterator();it.hasNext();){
        // String s=it.next();
        // System.out.println(s);
        // }
        //问题:增强for可不可以操作Set集合?
        for(String s:set){
            System.out.println(s);
        }
    }
}

 

6.Hashset保证元素的唯一性的源码解析

  1.Hashset的底层实现是Hashmap实现的

  在上面的案例中，我们使用HashSet只涉及到了两个方法。

A．new HashSet

B．  add方法

我们调用new HashSet方法其实就是其底层建立了一个hashmap。

7关于hash的问题

 在object中有一个hashcode方法，这个方法的返回值就是hash码。关于hashCode方法的一个常规协定:相等的对象应该具有相等的hash码.

8.hashSet保证元素唯一性的代码体现及图解

hashCode值的计算简单说，就是将对象中的属性的值相加

如果属性是基本数据类型，直接加

如果属性是引用类型，就得到其hash值在相加，它们的结果乘以了一个质数，目的是为了减少重复率。

 

public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

 

9.linkedHashSet的概述和使用

  linkedHashSet特点：保证数据元素的顺序（存入顺序和取出顺序一致）

public class LinkedHashSetDemo {

    public static void main(String[] args) {
        LinkedHashSet<String> set = new LinkedHashSet<String>();

        set.add("a");
        set.add("b");
        set.add("k");
        set.add("d");
        
        System.out.println(set);
    }
}

 

10.treeSet的概述和使用

A．特点： 不重复，可以对集合中元素进行排序。

B．比较器：comparator

C．自然顺序：comparable

  D．TreeSet保证集合元素的唯一性

  是用过自然顺序或者比较器来判断的。

public class TreeSetDemo1 {

    public static void main(String[] args) {
        //1.创建TreeSet
        TreeSet<Integer> set=new TreeSet<Integer>();
        //2.向TreeSet中装入Integer数据
        set.add(3);
        set.add(1);
        set.add(7);
        set.add(2);
        set.add(8);
        
        //3.遍历TreeSet
        for(int n:set){ //注意，类型应该是Integer,但是jdk1.5提供也自动拆箱，所以可以写int。
            System.out.println(n);
        }
    }
}

 

11. treeSet保证元素唯一性和排序代码解析。

基于 TreeMap 的 NavigableSet 实现。

使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，

具体取决于使用的构造方法。

1. new TreeSet();----à在TreeSet底层使用的是一个NavigableMap
2. 当调用put方法是，我们通过源代码连接时，是链接到Map接口，接口中没有具有的方法实现，这时我们就可以在Map接口中查找它的实现类   NavigableMap接口。
3. 在NavigableMap这个接口中也没有put方法实现，那么在看这个接口的实现类，

TreeMap中有put方法实现

13．TreeSet保证元素唯一性和自然顺序的原理和图解

1. 当装入第一个元素时，因为集合中没有其它元素，那么它就是根
2. 所有元素在装入时，如果是小的一直放在左边，大的放在右边，相等的不装入。

3．问题:怎样比较的集合中的元素?

         在源代码中有:

         Comparator------比较器

Comparable----- 自然顺序

什么是自然顺序?

实现了Comparable接口的类就具有了自然顺序，它比较时是通过接口中要重写的方法compareTo来完成的，这个方法返回的是int类型的值，0代表的是等于,负数代表的是小于,正数代表的是大于.

 

比较器:在创建TreeSet时指定一个比较器

比较器就是实现了Comparator接口的一个类，那么这个类需要重写接口中一个方法compare，这个方法返回的是int类型值，它的原理与comparTo方法一样。