Data19A list 增强for循环 List存储学生对象用3种方式遍历 数据结构 List集合子类特点 LinkList集合特有的功能 set集合 哈希值

pofenx
67 阅读2分钟 
package Demo24;
//写一个程序，计算1—1/2+1/3-1/4+1/5++++1/10000000
public class Demo24 {
    public static void main(String[] args) {
     double a =0,b=0;
        for (int i = 1; i <1000000000 ; i++) {
       if(i%2==1){
           a=a+(double) 1/i;
       }else{
           b=b+(double) 1/i;
       }
        }
        System.out.println(a-b);
    }
}

list

在这里插入图片描述

  • List概述
  1. 有序集合（也称为序列），用户可以精确控制列表中每一个元素的位置，用户2可以通过整数索引访问元素，并搜索列表中的元素
  2. 与Set集合不同，列表通常允许重复的元素
  • 特点
  1. 有序，储存和取出的元素的顺序一致
  2. 可重复：储存的元素可以重复
package Demo24;

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

//写一个程序，计算1—1/2+1/3-1/4+1/5++++1/10000
public class Demo24 {
    public static void main(String[] args) {
        List<String> c =new ArrayList<>();
        c.add("Hello");
        c.add("Java");
        c.add("world");
        //void add(int index ,Eelement ）在此集合中的指定位置插入指定元素‘
      //  c.add(1,"javaee");
        //c.add(11,"javaee");//IndexOutOfBoundsException
        //E remove (int index),移除指定所引处元素，返回被删除的元素
       // System.out.println(c.remove(1));
       // c.remove(11);//IndexOutOfBoundsException
        // E set(int index,E element),修改指定处的元素，返回被修改的元素
     //   System.out.println(c.set(1,"javace"));
//输出集合对象
       // System.out.println(c);
        //遍历集合
        System.out.println(c.get(0));
        System.out.println(c.get(1));
        System.out.println(c.get(2));
        //遍历集合（for修改）
        for (int i = 0; i <c.size() ; i++) {
            String s = c.get(i);
            System.out.println(s);
        }
    }
}
  • 案例：List集合储存学生对象并遍历
package Demo24;

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

public class Demo24 {
    public static void main(String[] args) {
        List<Student> c =new ArrayList<>();
      Student s1 =new Student("POFENX1",17);
      Student s2 =new Student("POFENX1",117);
      Student s3 =new Student("POFENX",1117);
      c.add(s1);
      c.add(s2);
      c.add(s3);

        //遍历集合（for修改）
        for (int i = 0; i <c.size() ; i++) {
            Student s = c.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

//列表迭代器
package Demo25;

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

public class Demo25 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("java1");
        list.add("java2");
        list.add("java3");
        //获取列表迭代器
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            if (s.equals("java2")) {
                lit.add("java1-2");
            }
        }
        System.out.println(list);
    }
}

增强for循环

格式

for(元素数据类型 变量名 ： 数组或者Collection集合){

//在此处使用变量即可，改变量就是元素1

}

范例：

int[] arr = {1,2,3};

for(int i : arr){

System.out.println(i);

}

package Demo25;

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

public class Demo25 {
    public static void main(String[] args) {
    int[] arr = {1,2,3,4,5};
        for (int i : arr) {
            System.out.println(i);
        }
        System.out.println("------------");
        String[] str ={"pofenx1","pofenx2","pofenx3"};
         for(String i : str){
             System.out.println(i);

        }
        System.out.println("------------------");
         List<String> list = new ArrayList<>();
         list.add("pofenA");
         list.add("pofenB");
         list.add("pofenC");
         for(String i : list){
             System.out.println(i);
         }
        System.out.println("-----------");
         //其内部原理是Iterator迭代器
        for(String s : list){
            if(s.equals("pofenA")){
                list.add("javaA");//出现并发异常ConcurrentModificationException       

            }
    }
}}

List存储学生对象用3种方式遍历

  • 迭代器
  • 普通for
  • 增强for
package Demo24;

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

public class Demo24 {
    public static void main(String[] args) {
        List<Student> c =new ArrayList<>();
      Student s1 =new Student("POFENX1",17);
      Student s2 =new Student("POFENX1",117);
      Student s3 =new Student("POFENX",1117);
      c.add(s1);
      c.add(s2);
      c.add(s3);
        Iterator<Student>  it = c.listIterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("----------------------");
        //普通for
        for (int i = 0; i <c.size() ; i++) {
            Student s = c.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("----------------------");
        //增强for
        for(Student s : c){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

数据结构

  • 数据结构是计算机储存，组织数据的方式，是指相互之间存在一种或多种特定关系的数据元素集合
  • 通常情况下，精心的的数据结构能带来更高的运行或者储存效率

常见数据结构之栈

  • 数据进入栈的过程称为压栈/进栈
  • 数目离开栈
  • 栈是一种先进后出模型

常见数据结构之队列

数据从后端进入队列模型的过程称为：入队列

数据从前端离开队列模型的过程称为：出队列

  • 队列是一种先进先出的模型

常见数据结构之数组：数组是一种查询快，增删慢的模型

  • 查询通过索引定位，查询任意数据耗时相同，查询效率高
  • 删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
  • 添加数据时，天剑位置后的每一个数据后移，添加元素，添加效率低

常见数据结构之链表

在这里插入图片描述 在这里插入图片描述

List集合子类特点

list集合常用子类

  • ArrayList：底层数据结构是数组，查询快，增删慢
  • LinkList：底层数据结构是链表，查询慢，增删快

练习：分别使用ArratList和LinkedList完成储存字符并遍历

package Demo26;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;

public class Demo26 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<>();
        array.add("pofenx1");
        array.add("pofenx2");
        array.add("pofenx3");
        for(String s :array){
            System.out.println(s);
        }
        System.out.println("-----------------");
        Iterator<String> lit= array.iterator();
        while (lit.hasNext()){
            String s = lit.next();
            System.out.println(s);
        }
        System.out.println("-----------------");
        for (int i = 0 ;i<array.size();i++){
            String s = array.get(i);
            System.out.println(s);
        }
        System.out.println("-----------------");
        LinkedList<String> array1 = new LinkedList<>();
        array1.add("pofenMAX1");
        array1.add("pofenMAX2");
        array1.add("pofenMAX3");
        Iterator<String>  lit1 = array1.iterator();
        while(lit1.hasNext()){
            String s1 = lit1.next();
            System.out.println(s1);
        }
        System.out.println("--------------------");
        for(String i : array1){
            System.out.println(i);
        }
        System.out.println("-------------------");
        for(int i = 0 ;i<array1.size();i++){
            String s2 = array1.get(i);
            System.out.println(s2);
        }
    }
}

LinkList集合特有的功能

package Demo27;

import java.util.LinkedList;

public class Demo27 {
    public static void main(String[] args) {
        LinkedList<String> lin = new LinkedList<>();
        lin.add("A1");
        lin.add("A2");
        lin.add("A3");
        //public void addFirst(E e),在该列表开头插入指定元素
        //public void addLast(E e),将指定元素追加到此元素的末尾
        //  lin.addFirst("B1");
        //lin.addLast("B2");
        //System.out.println(lin);//[B1, A1, A2, A3, B2]

       // System.out.println(lin.getFirst());//返回此列表的第一个元素
        //System.out.println(lin.getLast());//返回此列表的最后一个元素

        System.out.println(lin.removeFirst());//从此列表中删除并返回第一个元素
        System.out.println(lin.removeLast());//从此列表中删除并返回最后一个元素
        System.out.println(lin);
    }
}

set集合

  • set集合的特点
  1. 不包含重复元素的集合
  2. 没有带索引的方法，所以不能使用普通for循环遍历

Set集合练习

  • 储存字符串并遍历
package Demo28;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Demo28 {
    public static void main(String[] args) {
        Set<String> s = new HashSet<>();//HashSet：对集合的迭代顺序不做任何保证
        s.add("Hello");
        s.add("World");
        s.add("Java");
        for(String i : s){
            System.out.println(i);
        }
        System.out.println("-----------");
        Iterator<String> s1 =s.iterator();
        while(s1.hasNext()){
            String s2 = s1.next();
            System.out.println(s2);
        }
    }
}
/*
Java
Hello
World
-----------
Java
Hello
World

 */

哈希值

哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中的 public int hashCode()：返回对象的哈希码值

对象的哈希值特点

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
  • 默认情况下，不同对象的哈希值是不同的，而重写hashCode方法，可以实现让不同对象的哈希码值相同
public int hashCode(){
    return 0 ;
}

package Demo24;

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

public class Demo24 {
    public static void main(String[] args) {
      Student s1 =new Student("POFENX1",17);
      Student s2 =new Student("POFENX1",117);
      Student s3 =new Student("POFENX",1117);
        System.out.println(s1.hashCode());//460141958
        System.out.println(s1.hashCode());//460141958
        System.out.println(s2.hashCode());//1163157884
        System.out.println(s3.hashCode());//1956725890
        System.out.println("Hello".hashCode());//69609650
        System.out.println("World".hashCode());//83766130
        System.out.println("World".hashCode());//83766130
        System.out.println("Java".hashCode());//2301506
        System.out.println("帅哥".hashCode());//767872
        System.out.println("机器人".hashCode());//26101260
        System.out.println("机器人".hashCode());//26101260
        }
    }
avatar
文章
阅读
粉丝