java第六周学习笔记:

最新推荐文章于 2022-09-13 23:09:45 发布

@十里~顾清欢

最新推荐文章于 2022-09-13 23:09:45 发布

阅读量83

点赞数

文章标签： java eclipse 1024程序员节

本文链接：https://blog.csdn.net/weixin_46657047/article/details/120835975

版权

1.包装类
1.0概念:

  基本数据类型所对应的引用数据类型;Object可同一所有数据,包装类的默认值是null.
    byte       Byte
    short      Short
    int        Integer
    long       Long
    float      Float
    double     Double
    char       Character
    boolean    Boolean

1.0将Int转换为字符串

<1>public static String toBinaryString(int i):将整数转换字符串形式的二进制

<2>public static String toOctalString(int i) :将整数转换字符串形式的八进制

<3>public static String toHexString(int i):将整数转换成字符串形式的十六进制

    System.out.println(Integer.toBinaryString(100)) ;
    System.out.println(Integer.toOctalString(100)) ;
    System.out.println(Integer.toHexString(100)) ;

1.2求int类型的取值范围

<1>public static final int MAX_VALUE: 求最大值

System.out.println(Integer.MAX_VALUE) ;

<2>public static final int MIN_VALUE: 求最小值

  System.out.println(Integer.MIN_VALUE) ;

注意:

jdk5以后:自动拆箱和装箱. 基本数据类型和包装类自动转换.

装箱:基本数据类型---引用数据类型拆箱:引用数据类型----基本数据类型

1.3Integer的构造方法

Integer(int value):将int类型构造成Integer对象

Integer(String s) 将String类型构造成Integer对象: 注意:要使用第二个构造方法,前提是必须是数字

字符串,否则会抛出异常:throws NumberFormatException .

   int i = 100 ;
    Integer ii = new Integer(i) ;
    System.out.println(ii);
     
    String s = "200" ;
    Integer i2 = new Integer(s) ;
    System.out.println("i2:"+i2) ;

1.4基本功能

<1>public static Integer valueOf(int i): int----integer

<2>public static Integer valueOf(String s): String-----Integer

<3>public int intValue(): Integer-----Int 转换为六种基本类型

<4>public String toString(): 返回String表示此对象Integer的价值 Integer------String

<5>public static String toString(int i); int -----String

<6>parseInt(String s): 将字符串解析为带符号的十进制整数 String-----int

1.5典型例题:看程序,写结果

注意:看当前传进来的整数值是否在内存缓冲区-128-127之间;如果在直接取值,如果不在,就会创建

新的Integer对象.

    public class IntegerTest {
        public static void main(String[] args) {
            Integer i1 = new Integer(127) ;
            Integer i2 = new Integer(127) ;
            System.out.println(i1==i2) ;//false
            System.out.println(i1.equals(i2)) ;//true
     
            Integer i3 = new Integer(127) ;
            Integer i4 = 127 ;
            System.out.println(i3==i4) ;//false
            System.out.println(i3.equals(i4)) ;//true
     
            Integer i7 = new Integer(128) ;
            Integer i8 = 128 ;  //超了范围-128 ~127  new Ineteger(128) ;
            System.out.println(i7==i8) ;//false
            System.out.println(i7.equals(i8));//true
     
            Integer i5 = new Integer(128) ;
            Integer i6 = new Integer(128) ;
            System.out.println(i5==i6) ; //false
            System.out.println(i5.equals(i6));//true
     
            Integer i9 = 128 ;  //-128-127
            Integer i10 = 128 ;
            System.out.println(i9==i10) ; //false
            System.out.println(i9.equals(i10));//true
     
            Integer k1 = 100;
            Integer k2 = 100;
            System.out.println(k1 == k2);//true
            System.out.println(k1.equals(k2));//true
     
        }
    }

1.6String----与int相互转换

(1)int-----String

<1>方式1:空串拼接

    int i = 100 ;
    String result = ""+i ;
    System.out.println("result:"+result);//"100"

<2>利用Integer中间桥梁

    int i = 100 ;
    Integer ii = new Integer(i) ;
    String result2 = ii.toString();

<3>利用Integer静态方法: public static String toHexString(int i):返回16进制无符号整数值的字符串

    int i  = 100;
    String result3 = Integer.toHexString(i);

(2)String-----int

<1>Integer构造方法+intValue()

    String s = "50" ;
    Integer i1 = new Integer(s) ;
    int intResult = i1.intValue();

<2>Integer静态功能直接转换: public static int parseInt(String s)

  String s = "50" ;
    int intResult2 = Integer.parseInt(s) ;

1.java.util.Date:表示日期格式:精确到瞬间毫秒

*1)public Date():无参构造方法,获取当前系统时间的日期格式默认使用当前系统时间

public class ScannerTest {
    public static void main(String[] args) {  
      Date date = new Date();
      System.out.println(date);   Mon Oct 18 22:04:57 CST 2021
    }
}

2)public Date(long date):将long类型-构造成Date对象:long指定时间毫秒值(与1970年1月1日)

public class DateDemo {
    public static void main(String[] args) {
        long time = 60 * 60 ;
        Date date2 = new Date(time) ;
        System.out.println(date2);    结果:Thu Jan 01 08:00:03 CST 1970
    }
}

3)public long getTime():将Date日期格式----转换成long类型返回自1970年1月1日以来的Date毫秒数

public class DateDemo {
    public static void main(String[] args) {     
        Date date = new Date() ;
        long times = date.getTime();
        System.out.println(times);     结果:1634566957688  1970年当前值的毫秒值.
    }
}

4)String 日期文本格式如何和Date格式之间的转换

1) String 日期文本格式如何和Date格式之间转换?
    转换这儿有一个日期文本格式"DateFormat"(日期格式化)  有一个包厢"java.text " 文本格式.
   public abstract class DateFormat(抽象方法) extends Format.

     DateFormat是日期/时间格式化子类的抽象类，它以语言无关的方式格式化和分析日期或时间。但是它是一个抽象类
     抽象类不能实例化,它提供了更具体的子类SimpleDateFormat进行操作!
 

 java.util.Date对象------  SimpleDateFormat     ------->String 日期文本格式     :格式化过程
 "SimpleDateFormat"父类有一个方法叫format()方法(public final String format(Date date))   将日期转化成字符串类型.
 *
 *                          yyyy:表示年    2009
 *                          MM:月           07/11
 *                          dd:月中的天     01
 *
 *                          HH:小时数      14  (24小时制)
 *                          mm:分钟数      02
 *                          ss:描述        03

public class DateDemo2 {
    public static void main(String[] args) throws ParseException {
  1)  *** Date---->String 日期文本***
        //创建日期对象:表示当前系统时间
        Date date = new Date() ;

        //创建SimpleDateFormat对象:中间桥梁(格式化/解析 工具)
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;时间模式  注:可以更改 "yyyy-MM-dd" 2021-10-18
        //  public final String format(Date date)
        String dateStr = sdf.format(date);
        System.out.println(dateStr) ;    2021-10-18 22:56:40   结果:当前系统时间格式
 
    }
}
2)  *** String---->Date 日期文本**
public class DateDemo2 {
    public static void main(String[] args) throws ParseException {

        //String文本------->Date日期格式
        String sourc = "2008-5-12" ;
        //当前的SimpleDateFormat的模式必须和字符串文本格式对应!,否则解析出问题了
        //创建SimpleDateFormat对象
       // SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日" ) ;
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd" ) ; 模式必须一样.
        //public Date parse(String source) throws ParseException:
        Date date2 = sdf2.parse(sourc);
        System.out.println(date2) ;//Mon May 12 00:00:00 CST 2008
    }
}

面试题:

1.boolean retainAll(Collection c): 求集合中的交集元素,boolean的表达式意思是什么?
A集合对B集合求交集,boolean 什么情况true/什么情况下false

将交集的元素保存A集合中,boolean表达的意思:将保存在A集合中的元素是否和之前的元素发生变化
如果前后发生变化,则返回true;没有变化,则返回false!

e)Collection的Iterator原码_体系结构

//实现这个接口类的对象---使用 foreach:增强for循环
interface Iterable{
        Iterator<T> iterator() ;
}


//根接口
interface Collection{
        Iterator<E> iterator() ; //抽象方法
}

interface List extends Collection{
    Iterator<E> iterator();
}


//具体的类
class ArrayList implements List{


        //实现这个方法
        public Iterator<E> iterator() {
               return new Itr(); //接口的子实现类对象...   接口多态
         }


         //私有的成员内部类

        private class Itr implements Iterator<E> {


                        int cursor;       // index of next element to return
                        int lastRet = -1; // index of last element returned; -1 if no such
                        int expectedModCount = modCount;

                        Itr() {}
                        //被ArrayList内部类:来进行实现
                        public boolean hasNext() {
                            return cursor != size;
                        }

                        //被实现了
                        @SuppressWarnings("unchecked")
                        public E next() {
                            checkForComodification();
                            int i = cursor;
                            if (i >= size)
                                throw new NoSuchElementException();
                            Object[] elementData = ArrayList.this.elementData;
                            if (i >= elementData.length)
                                throw new ConcurrentModificationException();
                            cursor = i + 1;
                            return (E) elementData[lastRet = i];
                        }

        }
}

2.Collection集合的高级功能

1)boolean addAll(Collection c):添加一个集合中的所有元素

public class CollectionDemo {

    public static void main(String[] args) {

        //创建两个集合
        Collection c1 = new ArrayList() ;
        c1.add("abc1") ;
        c1.add("abc2") ;
        c1.add("abc3") ; 
        c1.add("abc4") ;   
        Collection c2 = new ArrayList() ;
        c2.add("abc5") ;
        c2.add("abc6") ;
        c2.add("abc7") ;
        System.out.println("c1:"+c1) ;  c1:[abc1, abc2, abc3, abc4]
        System.out.println("c2:"+c2) ;  c2:[abc5, abc6, abc7]

        //boolean addAll(Collection c):添加一个集合中的所有元素
        System.out.println("addAll():"+c1.addAll(c2));
        System.out.println("c1:"+c1) ;  c1:[abc1, abc2, abc3, abc4, abc5, abc6, abc7]
        System.out.println("c2:"+c2) ;  c2:[abc5, abc6, abc7]
    }
}

2) boolean containsAll(Collection c):包含一个集合的所有元素 (思考:包含一个算包含,还是所有元素) 包含所有

2)第一种方式:
public class CollectionDemo {

    public static void main(String[] args) {

        //创建两个集合
        Collection c1 = new ArrayList() ;
        c1.add("abc1") ;
        c1.add("abc2") ;
        c1.add("abc3") ;
        c1.add("abc4") ;
        c1.add("abc5") ;
        c1.add("abc6") ;
        c1.add("abc7") ;


        Collection c2 = new ArrayList() ;


        c2.add("abc5") ;
        c2.add("abc6") ;
        c2.add("abc7") ;

        //boolean containsAll(Collection c):包含一个集合的所有元素 (思考:包含一个算包含,还是所有元素) 包含所有
      System.out.println(c1.containsAll(c2));   结果:true
 
        System.out.println("c1:"+c1) ;  c1:[abc1, abc2, abc3, abc4, abc5, abc6, abc7]
 
        System.out.println("c2:"+c2) ;  c2:[abc5, abc6, abc7]


    }
}

2)第二种方式:
    public static void main(String[] args) {

        //创建两个集合
        Collection c1 = new ArrayList() ;
        c1.add("abc1") ;
        c1.add("abc2") ;
        c1.add("abc3") ;
        c1.add("abc4") ;
        c1.add("abc5") ;
      


        Collection c2 = new ArrayList() ;


        c2.add("abc5") ;
        c2.add("abc6") ;
        c2.add("abc7") ;

        //boolean containsAll(Collection c):包含一个集合的所有元素 (思考:包含一个算包含,还是所有元素) 包含所有
      System.out.println(c1.containsAll(c2));   结果:felse
 
        System.out.println("c1:"+c1) ;  c1:[abc1, abc2, abc3, abc4, abc5]
 
        System.out.println("c2:"+c2) ;  c2:[abc5, abc6, abc7]


    }
}

3)boolean removeAll(Collection c):删除一个算删除还是删除所有算删除?  
  结论:删除一个集合中包含另一个集合中的某个元素,就算删除,返回true

public class CollectionDemo {

    public static void main(String[] args) {

        //创建两个集合
        Collection c1 = new ArrayList() ;
        c1.add("abc1") ;
        c1.add("abc2") ;
        c1.add("abc3") ;
        c1.add("abc4") ;
        c1.add("abc5") ;
  

        Collection c2 = new ArrayList() ;


        c2.add("abc5") ;
        c2.add("abc6") ;
        c2.add("abc7") ;

        //boolean removeAll(Collection c):删除一个算删除还是删除所有算删除?
        System.out.println(c1.removeAll(c2)); true

      
        System.out.println("c1:"+c1) ;  c1:[abc1, abc2, abc3, abc4,]

        System.out.println("c2:"+c2) ;  c2:[abc5, abc6, abc7]


    }
}

public class CollectionDemo {

    public static void main(String[] args) {

        //创建两个集合
        Collection c1 = new ArrayList() ;
        c1.add("abc1") ;
        c1.add("abc2") ;
        c1.add("abc3") ;
        c1.add("abc4") ;
        c1.add("abc5") ;
        c1.add("abc5") ;
        c1.add("abc6") ;
        c1.add("abc7") ;

        Collection c2 = new ArrayList() ;


        c2.add("abc5") ;
        c2.add("abc6") ;
        c2.add("abc7") ;

        //boolean removeAll(Collection c):删除一个算删除还是删除所有算删除?
        System.out.println(c1.removeAll(c2)); felse

      
        System.out.println("c1:"+c1) ;  c1:[abc1, abc2, abc3, abc4,abc5,abc6,abc7]

        System.out.println("c2:"+c2) ;  c2:[abc5, abc6, abc7]


    }
}

1)迭代器:

概念:
   集合专有遍历方式

2) Iterator(迭代器接口类型):
1) boolean hasNext() 判断是否有下一个可以迭代的元素 (判断功能)
2)Object next():获取下一个可以迭代的元素 (获取功能)

public class CollectionDemo2 {
    public static void main(String[] args) {
        //创建一个Collection集合,给里面存储字符串数据
        Collection c = new ArrayList() ;

        //添加字符串数据
        c.add("hello") ;
        c.add("world") ;
        c.add("java") ;

        //Iterator<E> iterator():迭代器
        Iterator it = c.iterator();
        Object obj = it.next() ;
        System.out.println(obj) ;

        //Object next():获取下一个可以迭代的元素
        //第一次获取
        /*Object obj = it.next() ;
        System.out.println(obj) ;

        //第二次获取
        System.out.println(it.next()) ;
        //第三次获取
        System.out.println(it.next()) ;*/

        //第四次获取
       // System.out.println(it.next());//java.util.NoSuchElementException 没有元素了

        //优化:迭代器Iterator接口提供了一个方法:boolean hasNext() 判断是否有下一个可以迭代的元素
        //第一次获取
        /*if(it.hasNext()){
            //成立,获取元素
            System.out.println(it.next());
        }
        //第二次获取
        if(it.hasNext()){
            System.out.println(it.next()) ;
        }
        //第三次获取
        if(it.hasNext()){
            System.out.println(it.next()) ;
        }
        //第四次获取
        if(it.hasNext()){
            System.out.println(it.next()) ;
        }*/

        //优化:元素都是自己添加的,后期的元素都是来自数据库中
        //通用 代码:while循环
        while(it.hasNext()){
            //System.out.println(it.next()) ;
            //Object obj = it.next();//里面存储的String  Objecg obj = new String() ;
            //获取元素的同时,获取字符串长度

            String s = (String) it.next();
            System.out.println(s+"---"+s.length());

        }


    }
}

1)泛型:

a)概念:

    使用<引用数据类型>
    集合对象的创建同时明确数据类型,并且将运行时期异常提前到了编译时期(模拟数组定义)

b)好处:

             1)提高程序安全性
             2)解决黄色警告线
             3)使用集合的迭代器避免强转类型强转类型转换

c)案例

//使用数组存储5个学生,学生有姓名和年龄,(对象数组),将数组学生信息遍历出来，
使用Collection集合进行遍历（看API分别使用迭代器Iteraotr和toArray（）完成）
public class Student {
    private String name ;
    private int age ;
    private String gender ;

    public Student() {
    }

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    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 String getGender() {
        return gender;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}
public class GenericTest {

    public static void main(String[] args) {

        //创建Collection集合
        Collection<Student> c = new ArrayList<>() ;  //加入泛型后运行时期异常提前编译时期.

        //创建4个学生:古代四大美女
        Student s1 = new Student("貂蝉",32,"女") ;
        Student s2 = new Student("王昭君",30,"女") ;
        Student s3 = new Student("西施",25,"男") ;
        Student s4 = new Student("杨玉环",28,"女") ;

        c.add(s1) ;
        c.add(s2) ;
        c.add(s3) ;
        c.add(s4) ;

        //获取迭代器
        Iterator<Student> iterator = c.iterator();
        while(iterator.hasNext()){ //不明确循环次数

            //String s = iterator.next() ;//将运行时期异常提前到编译时期,解决程序安全性
             Student s = iterator.next() ; //使用一次,获取整个的学生对象(s1,s2...s5)使用s接收
            System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGender()) ;


            //next()使用的时候,不能使用多次,否则造成数据丢失!
            /*System.out.println(iterator.next().getName()
                    +"----"+iterator.next().getAge()+"----"+iterator.next().getGender());*/
        }

        System.out.println("--------------------------------------------------------") ;
        //for循环可以使用:但是使用还是通用模板:while循环
       /* for(Iterator<Student> it2 = c.iterator() ;it2.hasNext();){
            Student student = it2.next();//也不用向下转型
            System.out.println(student.getName()+"---"+student.getAge()+"---"+student.getGender()) ;
        }*/
    }
}

d)将泛型定义在类上:

提供这个类ObjectTool,两个方法:赋值,获取值
 */
public class ObjectTool {

    private Object obj ; //声明变量obj

    //赋值的方法
    public void set(Object obj){//"高圆圆"  Object obj = new String("高圆圆") ;
        this.obj = obj ;
    }

    //获取值的方法
    public Object get(){
        return  obj ;
    }
}
 * 没有使用泛型之前:可能会出现程序安全性!
 */
public class ObjectToolTest {
    public static void main(String[] args) {

        //创建ObjectTool类的对象
        ObjectTool ot = new ObjectTool() ;
        ot.set("高圆圆");

        //获取值的
       // Integer i = (Integer) ot.get(); //编译没有报错,但是一运行:java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
        //System.out.println(i) ;
        String name = (String) ot.get();
        System.out.println("姓名是:"+name);

        System.out.println("------------------------") ;
        ot.set(new Integer(25));

       /* String s = (String) ot.get();
        System.out.println(s);*/
       Integer age = (Integer) ot.get();
        System.out.println("年龄是:"+age);
    }
}

e)将泛型定义在方法上:

public class ObjectTool {//将泛型定义在方法上

    /**
     * 泛型定义在方法上的格式:权限修饰符 <T> 返回值类型 方法名(T 参数名){...}
     * 固定格式  T--->Type 任何类型
     */
    public <T> void show(T t){
        System.out.println(t) ;
    }
}

public class ObjectToolTest {

    public static void main(String[] args) {

        //将泛型定义在方法上

        ObjectTool ot = new ObjectTool() ;
        ot.show("高圆圆") ;
        ot.show(100) ;
        ot.show(true) ;
        ot.show(12.56);

    }
}

List集合

1)特点:

 有序:存储和取出一致
       元素可以重复!

2)oid add(int index, Object element):在指定位置处添加一个新的元素

public class Test {
    public static void main(String[] args) {

        //创建List集合对象
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("javaee");

        // void add(int index, Object element):在指定位置处添加一个新的元素
        list.add(2, "鸿蒙系统");
        System.out.println(list);

    }
}
     [hello, world, 鸿蒙系统, javaee]

3)Object remove(int index):删除指定位置处的元素

public class Test {
    public static void main(String[] args) {

        //创建List集合对象
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("javaee");

         // Object remove(int index):删除指定位置处的元素(获取角标为1的值)
         System.out.println(list.remove(1)) ;

    }
}
                                       [hello, javaee]

4)Object set(int index, Object element):修改指定位置处的元素内容

public class ListDemo {
    public static void main(String[] args) {

        //创建List集合对象
        List<String> list = new ArrayList<>() ;

        //添加元素
        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;

        // Object set(int index, Object element):修改指定位置处的元素内容
        System.out.println(list.set(1,"Android"));    [hello,Android,javaee]
   }
}

5)Object get(int index):获取指定位置处的元素

public class ListDemo {
    public static void main(String[] args) {

        //创建List集合对象
        List<String> list = new ArrayList<>() ;

        //添加元素
        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;

        // Object get(int index):获取指定位置处的元素
        System.out.println(list.get(0)); hello
        System.out.println(list.get(1)); Androidx
        System.out.println(list.get(2)); javaee
        System.out.println(list);  [hello,Androidx,javaee]
  
    
   }
}

6)List集合的遍历方式有几种:

public class ListDemo {
    public static void main(String[] args) {

        //创建List集合对象
        List<String> list = new ArrayList<>() ;

        //添加元素
        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;
    
        //List集合的遍历方式有几种:
        //三种
        //方式1:Collection集合的toArray()----Object[]
        Object[] objects = list.toArray();
        for(int x = 0 ; x < objects.length ;x ++){
            String s = (String) objects[x];
            System.out.println(s+"----"+s.length());
        }
        //方式2:Coillection集合的Iterator迭代器
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            String s = iterator.next() ;
            System.out.println(s+"----"+s.length());
        }
        //方式3:get(int index) + size() 的普通for循环
        for(int x = 0 ; x < list.size(); x++){
            String s = list.get(x);
            System.out.println(s+"----"+s.length());
        }


    }
}                 hello----5
                  Android----7
                  javaee----6

2.增强for循环

1)作用:

代替迭代器

2)格式:

for(泛型数据类型 变量名 : 集合对象名称){  //增强for循环 遍历数组非常少,主要用在集合中
 *          输出变量名;
 *      }
 *

3前提条件:

 *      前提条件:集合对象不能为null,否则就出现空指针异常
 *

4)案例:

public class ForEachDemo {
    public static void main(String[] args) {

        //创建一个数组  **了解**
        int[] arr = {11,22,33,44,55} ;
        for(int x = 0 ; x < arr.length ; x ++){
            System.out.println(arr[x]);
        }
        System.out.println("-----------------------------") ;
        for(int i :arr ){
            System.out.println(i);
        }

        //主要集合中
        List<String> list = new ArrayList<>() ;

        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;
        list.add("android") ;

        /**
         *  for(泛型数据类型 变量名 : 集合对象名称){  //增强for循环 遍历数组非常少,主要用在集合中
         *  *          输出变量名;
         *  *      }
         */
        for(String s:list){
         
            System.out.println(s);
        }
    }
}

5)集合元素去重:

1)使用List存储多个字符串,有重复元素,如何去重!

使用List存储多个字符串,有重复元素,如何去重!
 *
 *
 *  分析:     新建集合思想
 *          1)创建一个List集合对象,给里面添加重复元素
 *          2)创建一个新的List集合,
 *          3)将以前的集合的元素遍历出来,使用集合对象判断,如果新集合中不包含这个元素,说明不重复,
 *              添加新集合中
 *          4)遍历新集合
 *
 *
 *      集合的contains(Object obj)底层依赖于equals方法,而String类型
 * 已经重写了equals,比较是内容是否相同;所以如果使用List<自定义类型>,去重,必须保证
 * 当前自定义类型重写Object的hashCode()和equals()
 *
 *
 * 需求2:1)创建一个List集合对象,给里面添加重复Student元素List<Student> :姓名和年龄一致,认为是同一个人
 *       新建集合思想
 */
public class ListTest2 {

    public static void main(String[] args) {

        //创建List集合对象
        List<String> list = new ArrayList<>() ;

        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;
        list.add("hello") ;
        list.add("world") ;
        list.add("world") ;
        list.add("hello") ;
        list.add("javaee") ;
        list.add("android") ;
        list.add("android") ;
        list.add("php") ;
        list.add("php") ;

        //创建一个新的集合
        List<String> newList = new ArrayList<>() ;
        //遍历旧集合获取每一个元素:增强for
        for(String s:list){
            //在新集合中判断是否包含这个元素,如果不包含,才给新集合中添加
            if(!newList.contains(s)){
                newList.add(s) ;
            }
        }
        //遍历新集合
        for(String s:newList){
            System.out.println(s);
        }
    }

}
***************改进******************
利用选择排序的业务思想:
 *      前面的元素依次和后面的元素比较,如果一致,将后面的元素删除掉!
 */
public class ListTest3 {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<>() ;

        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;
        list.add("hello") ;
        list.add("world") ;
        list.add("world") ;
        list.add("hello") ;
        list.add("javaee") ;
        list.add("android") ;
        list.add("android") ;
        list.add("php") ;
        list.add("php") ;

        //选择排序的核心代码
        for(int x = 0 ; x < list.size()-1; x++){
            for(int y = x+1 ; y < list.size() ; y ++){
                //业务思想:如果前面的元素和后面元素一致,将后面的重复元素删除掉
                if(list.get(y).equals(list.get(x))){
                    //将后面的元素删除
                    list.remove(y) ;
                    y -- ;
                }
            }
        }
        //遍历当前这个集合
        for(String s :list){
            System.out.println(s);
        }
    }
}

2)自定义类型(Student)List集合去重:

需求2:创建一个List集合对象,给里面添加重复Student元素List<Student> :姓名和年龄一致,认为是同一个人
 *         新建集合思想
 *
 *      集合的contains(Object obj)底层依赖于equals方法,而String类型
 *  * 已经重写了equals,比较是内容是否相同;所以如果使用List<自定义类型>,去重,必须保证
 *  * 当前自定义类型重写Object的hashCode()和equals()
 */
public class ListTest4 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>() ;

        //创建学生对象
        Student s1 = new Student("高圆圆",42) ;
        Student s2 = new Student("高圆圆",42) ;
        Student s3 = new Student("文章",35) ;
        Student s4 = new Student("马伊琍",44) ;
        Student s5 = new Student("姚笛",30) ;
        Student s6 = new Student("王宝强",38) ;
        Student s7 = new Student("马蓉",35) ;
        Student s8 = new Student("马蓉",35) ;
        Student s9 = new Student("姚笛",30) ;

        //添加list集合中
        list.add(s1) ;
        list.add(s2) ;
        list.add(s3) ;
        list.add(s4) ;
        list.add(s5) ;
        list.add(s6) ;
        list.add(s7) ;
        list.add(s8) ;
        list.add(s9) ;

        //创建一个新的集合
        List<Student> newList  = new ArrayList<>() ;
        //遍历旧集合
        for(Student student:list){
            //新集合不包含这个元素,说明不重复
            if(!newList.contains(student)){
                newList.add(student) ;
            }
        }
        //遍历新集合
        for(Student s:newList){
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

6) boolean hasNext() :判断当前列表中是否下一个可以遍历的元素 true
boolean hasPrevious():判断当前列表中是否有时上一个可以遍历的元素 true

public class ListDemo2 {

    public static void main(String[] args) {

        //创建List存储字符串数据并正向遍历:使用列表迭代器
        List<String> list = new ArrayList<>() ;

        //添加字符串
        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;
        list.add("鸿蒙") ;

        //ListIterator<E> listIterator():列表迭代器
       ListIterator<String> lit = list.listIterator(); //它的成员内部类:ListItr类继承内部类Itr  实现ListIterator()
      while(lit.hasNext()){
            String s = lit.next();
            System.out.println(s);
        }
        System.out.println("-----------------------------") ;
       while(lit.hasPrevious()) {
            String s = lit.previous();//获取上一个元素    和hasNext()一块使用 不然没有输出结果
            System.out.println(s);
        }
    }
}

hello
world
javaee
鸿蒙
-----------------------------
鸿蒙
javaee
world
hello

7.遍历:

public class ListTest {

    public static void main(String[] args) {

        //创建List
        List<Student> list = new ArrayList<>() ;

        //创建5个学生
        Student s1 = new Student("张雨",23) ;
        Student s2 = new Student("王辉",25) ;
        Student s3 = new Student("张佳杨",25) ;
        Student s4 = new Student("高圆圆",42) ;
        Student s5 = new Student("张佳宁",30) ;

        //添加
        list.add(s1) ;
        list.add(s2) ;
        list.add(s3) ;
        list.add(s4) ;
        list.add(s5) ;

        //遍历
        //方式3:
        for (int i = 0; i <list.size() ; i++) {
            Student student = list.get(i);
            System.out.println(student.getName()+"---"+student.getAge());
        }
    }
}
张雨---23
王辉---25
张佳杨---25
高圆圆---42
张佳宁---30

8.现在使用List存储字符串数据,遍历这个list集合,如果当前元素内容有"world",
需要给List中添加一个新的元素"php",

需求:
 *   现在使用List存储字符串数据,遍历这个list集合,如果当前元素内容有"world",
 *          需要给List中添加一个新的元素"php",
 */
public class ListTest {
    public static void main(String[] args) {

        //创建List集合
        List<String> list = new ArrayList<>() ;

        //现在有几个元素
        list.add("hello") ;
        list.add("world") ;
        list.add("java") ;

        //解决方案1:
        // 而ListIterator:列表迭代器中:有添加功能void add(E e)
        ListIterator<String> listIterator = list.listIterator();
        //遍历
        while(listIterator.hasNext()){
            //获取
            String s = listIterator.next();
            if("world".equals(s)){
                //迭代器添加
                listIterator.add("php"); //在指定元素后面插入
            }
        }*/


       //方式2:集合判断,集合添加
        //遍历
        for(int x = 0 ; x < list.size() ; x ++){

            String s = list.get(x) ;
            //判断
            if("world".equals(s)){
                //集合添加
                list.add("php");
            }
        }
        System.out.println(list);
    }
}

9.使用List存储多个字符串,有重复元素,如何去重!

第一种方式:
public class ListTest2 {

    public static void main(String[] args) {

        //创建List集合对象
        List<String> list = new ArrayList<>() ;

        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;
        list.add("hello") ;
        list.add("world") ;
        list.add("world") ;
        list.add("hello") ;
        list.add("javaee") ;
        list.add("android") ;
        list.add("android") ;
        list.add("php") ;
        list.add("php") ;

        //创建一个新的集合
        List<String> newList = new ArrayList<>() ;
        //遍历旧集合获取每一个元素:增强for
        for(String s:list){
            //在新集合中判断是否包含这个元素,如果不包含,才给新集合中添加
            if(!newList.contains(s)){
                newList.add(s) ;
            }
        }
        //遍历新集合
        for(String s:newList){
            System.out.println(s);
        }
    }

}
hello
world
javaee
android
php

第二种方式:
public class ListTest3 {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<>() ;

        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;
        list.add("hello") ;
        list.add("world") ;
        list.add("world") ;
        list.add("hello") ;
        list.add("javaee") ;
        list.add("android") ;
        list.add("android") ;
        list.add("php") ;
        list.add("php") ;

        //选择排序的核心代码
        for(int x = 0 ; x < list.size()-1; x++){
            for(int y = x+1 ; y < list.size() ; y ++){
                //业务思想:如果前面的元素和后面元素一致,将后面的重复元素删除掉
                if(list.get(y).equals(list.get(x))){
                    //将后面的元素删除
                    list.remove(y) ;
                    y -- ;
                }
            }
        }
        //遍历当前这个集合
        for(String s :list){
            System.out.println(s);
        }
    }
}
hello
world
javaee
android
php
3)去重  创建 equals  hashCode即可:
public class ListTest4 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>() ;

        //创建学生对象
        Student s1 = new Student("高圆圆",42) ;
        Student s2 = new Student("高圆圆",42) ;
        Student s3 = new Student("文章",35) ;
        Student s4 = new Student("马伊琍",44) ;
        Student s5 = new Student("姚笛",30) ;
        Student s6 = new Student("王宝强",38) ;
        Student s7 = new Student("马蓉",35) ;
        Student s8 = new Student("马蓉",35) ;
        Student s9 = new Student("姚笛",30) ;

        //添加list集合中
        list.add(s1) ;
        list.add(s2) ;
        list.add(s3) ;
        list.add(s4) ;
        list.add(s5) ;
        list.add(s6) ;
        list.add(s7) ;
        list.add(s8) ;
        list.add(s9) ;

        //创建一个新的集合
        List<Student> newList  = new ArrayList<>() ;
        //遍历旧集合
        for(Student student:list){
            //新集合不包含这个元素,说明不重复
            if(!newList.contains(student)){
                newList.add(student) ;
            }
        }
        //遍历新集合
        for(Student s:newList){
            System.out.println(s.getName()+"---"+s.getAge());
        }


    }
}

@十里~顾清欢

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java第六周学习笔记:

常用类:1.java.util.Date:表示日期格式:精确到瞬间毫秒*1)public Date():无参构造方法,获取当前系统时间的日期格式默认使用当前系统时间public class ScannerTest { public static void main(String[] args) { Date date = new Date(); System.out.println(date); Mon Oct 18 22:04:57 CST 202.
复制链接

扫一扫