精华内容
下载资源
问答
  • 集合和数组不一样,数组元素既可以基本类型的值,也可以是对象(对象的引用变量);而集合里只能保存对象(对象的引用变量)。 Java集合类主要由两个集合框架的根接口派生而出:Collection和Map Java中Collection接口的...

    在编程过程中,会很频繁的使用集合,集合的相关知识也非常重要,也是每一个开发人员必须掌握的知识。
    一:集合的概念
    集合:保存数量不确定的数据,以及保存具有映射关系的数据的容器,简单的理解就是用于存储数量不等的多个对象的容器。
    集合和数组不一样,数组元素既可以是基本类型的值,也可以是对象(对象的引用变量);而集合里只能保存对象(对象的引用变量)。
    Java集合类主要由两个集合框架的根接口派生而出:Collection和Map
    Java中Collection接口的体系机构:

    今天这篇文章主要对List接口集合下的实现类就行分析。
    总结概述
    1.List继承了Collection,是有序的列表。
    2.实现类有ArrayList、LinkedList、Vector、Stack等
    (1)ArrayList是基于数组实现的,是一个数组队列。可以动态的增加容量!
    (2)LinkedList是基于链表实现的,是一个双向循环列表。可以被当做堆栈使用!
    (3)Vector是基于数组实现的,是一个矢量队列,是线程安全的!
    (4)Stack是基于数组实现的,是栈,它继承与Vector,特性是FILO(先进后出)!
    使用场景
    在实际的应用中如果使用到队列,栈,链表,首先可以想到使用List。不同的场景下面使用不同的工具,效率才能更高!
    1 当集合中对插入元素数据的速度要求不高,但是要求快速访问元素数据,则使用ArrayList!
    2.当集合中对访问元素数据速度不做要求不高,但是对插入和删除元素数据速度要求高的情况,则使用LinkedList!
    3.当集合中有多线程对集合元素进行操作时候,则使用Vector!但是现在BVector现在一般不再使用,如需在多线程下使用,可以用CopyOnWriteArrayList,在java.util.concurrent包下。
    4.当集合中有需求是希望后保存的数据先读取出来,则使用Stack!
    性能测试
    /**

    • Copyright © 2018 westlife.All rights reserved.
    • @Package: com.test
    • @author: ys
    • @date: 2018年5月23日 上午10:20:54
      */
      package com.test;

    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Stack;
    import java.util.Vector;

    /**

    • Title: ListTest

    • Description:

    • Company: westlife

    • @author westlife
    • @date 2018年5月23日 上午10:20:54
      /
      /
    • 性能测试,通过插入、随机读取和删除对ArrayList、LinkedList、Vector和Stack进行测试!
    • 结论:看LinkedList
    • 插入10万个元素,LinkedList所花时间最短:17 ms。
    • 删除10万个元素,LinkedList所花时间最短: 9 ms。
    • 遍历10万个元素,LinkedList所花时间最长:10255 ms;而ArrayList、Stack和Vector则相差不多,都只用了几秒。
    • (1) 对于需要快速插入,删除元素,应该使用LinkedList。
    • (2) 对于需要快速随机访问元素,应该使用ArrayList。

    */
    public class ListTest {

    private static final int COUNT = 100000; //十万
    
    private static ArrayList<Object> arrayList = new ArrayList<Object>();
    private static LinkedList<Object> linkedList = new LinkedList<Object>();
    private static Vector<Object> vector = new Vector<Object>();
    private static Stack<Object> stack = new Stack<Object>();
    
    public static void main(String[] args) {
        System.out.println("....开始测试插入元素..........");
        // 插入元素测试
        insertData(arrayList,"ArrayList") ;
        insertData(linkedList,"LinkedList") ;
        insertData(vector,"Vector") ;
        insertData(stack,"Stack") ;
        System.out.println("....开始测试读取元素..........");
        // 随机读取元素测试
        readAccessData(arrayList,"ArrayList") ;
        readAccessData(linkedList,"LinkedList") ;
        readAccessData(vector,"Vector") ;
        readAccessData(stack,"Stack") ;
        System.out.println("....开始测试删除元素..........");
        // 随机读取元素测试
        deleteData(arrayList,"ArrayList") ;
        deleteData(linkedList,"LinkedList") ;
        deleteData(vector,"Vector") ;
        deleteData(stack,"Stack") ;
    }
    /**
     * 指定的List 的子类中插入元素,并统计插入的时间
     * @param list List 的子类
     * @param name 子类的名称
     */
    private static void insertData(List<Object> list,String name) {
        long startTime = System.currentTimeMillis();
    
        // 向list的位置0插入COUNT个数
        for (int i=0; i<COUNT; i++){
            list.add(0, i);
        }
        long endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println(name + " : 插入 "+COUNT+"元素, 使用的时间是 " + interval+" ms");
    }
    /**
     * 指定的List 的子类中删除元素,并统计删除的时间
     * @param list List 的子类
     * @param name 子类的名称
     */
    private static void deleteData(List<Object> list,String name) {
        long startTime = System.currentTimeMillis();
    
        // 删除list第一个位置元素
        for (int i=0; i<COUNT; i++)
            list.remove(0);
        long endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println(name + " : 删除 "+COUNT+"元素, 使用的时间是 " + interval+" ms");
    }
    /**
     * 指定的List 的子类中读取元素,并统计读取的时间
     * @param list List 的子类
     * @param name 子类的名称
     */
    private static void readAccessData(List<Object> list,String name) {
        long startTime = System.currentTimeMillis();
    
        // 读取list元素
        for (int i = 0; i < COUNT; i++)
            list.get(i);
    
        long endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println(name + " : 随机读取 "+COUNT+"元素, 使用的时间是 " + interval+" ms");
    }
    

    }
    运行结果:

    当然电脑的性能也会影响该时间,但是结果是显而易见的。
    从运行的结果可以看出,ArrayList和LinkedLis适用各自的场景中!
    为什么ArrayList读取速度快于LinkedList,而插入和删除速度又慢于LinkedList?
    有兴趣的可以研究下他们各自的源码,这里就不过多做分析了。

    展开全文
  • 1. 元组简介 元组基本介绍 • 元组表现形式tuple ...而列表list、字典dict、集合set是可变类型 可变对象中都保存了三个数据 • id(标识) • type(类型) • value(值) 3. 字典简介 3.1 字典的基本介绍
  • Collection 集合只能保存引用数据类型,不能保存基本数据类型 因为 底层就是 Object[] 数组,既然是Object 所以 即可以说只能保存Object单一元素,也可以说可以保存任何元素,因为Object是祖类,所有类型都会发生向上...

    1. Collection
    1.1 概述

    • 通过继承体系发现,集合中两大分类List和Set, 并且 两个都继承了Collection,那也就意味着Collection中的方法是List和Set都有的。

    • Collection 集合只能保存引用数据类型,不能保存基本数据类型

    • 因为 底层就是 Object[] 数组,既然是Object 所以 即可以说只能保存Object单一元素,也可以说可以保存任何元素,因为Object是祖类,所有类型都会发生向上转型(多态)

    • 基本类型真的不能存吗? 真的,因为基本类型和Object没有关系,但是 可以把基本类型转换为对应的包装类类型,而 包装类 是Object的子类,这样就能间接存储基本类型了

    • 常用方法 :

    •  	boolean add() : 添加元素
      
    •  	void clear() : 清空集合
      
    •  	boolean remove() 删除某个元素
      
    •  	boolean isEmpty() 判断集合中是否为空
      
    •  	boolean contains() : 是否包含某个元素
      
    •  	int  size() 返回集合中 元素个数
      

    下面是关于上述方法的一些代码测试:

    public static void main(String[] args) {
             //接口不能创建对象,我们以ArrayList为例,由于发生多态,丢失了ArrayList的特有方法
    		//所以我们现在能够调用的方法都是Collection中的
    		Collection c1=new ArrayList();
    		//判断集合中是否为空
    		System.out.println(c1.isEmpty());
    		
    		//添加元素
    		c1.add("as");
    		//12为int类型的,会先自动装箱为Integer类型的,然后再向上转型为Object类型的
    		c1.add(12);
    		
    		Object o1=new Object();
    		c1.add(o1);
    		// size不是数组的长度,而是数组中已经添加的元素个数
    		System.out.println(c1.size());
    		//转数组
    		Object[] arr=c1.toArray();
    		for (Object object : arr) {
    			System.out.println(object);
    		}
           
    		//删除,12为int类型的,自动装箱成Integer类型的,然后向上转型成Object类的
    		c1.remove(12);
    		//重新获取数组
    		arr=c1.toArray();
    		for (Object object : arr) {
    			System.out.println(object);
    		}
    		// 清空数组中元素
    		c1.clear();
    		//输出现有数组中元素的个数
    		System.out.println(c1.size());
    	}
    

    来深入理解一下

    • boolean contains(Object o) 判断集合中是否包含某个元素
    • boolean remove(Object o)在集合中删除指定元素
    • 这两个方法,底层都会去调用equals方法进行比较
    • 比如c.contains(“asd”)会用asd调用String的equals方法,挨个和集合中元素进行比较
    • remove也是一样,判断谁就用谁调用equals方法,和集合中元素进行比较
    • 所以如果是存储的自定义类型(类对象),就需要根据需求覆写equals方法
    public class Collection03 {
       public static void main(String[] args) {
              //创建集合
    		Collection c=new ArrayList();
    		Integer i1=new Integer(1);
    		Integer i2=new Integer(2);
    		//包装类是Object类的子类
    		c.add(i1);
    		c.add(i2);
    		Integer i4=new Integer(2);
    		//false 因为==比较引用类型比较的是地址,new了两次
    		System.out.println(i4==i2);
    		//true,因为调用的是Integer类的equals方法,重写了equals方法,比较的是值
    		System.out.println(i4.equals(i2));
    		// true,因为contains会自动调用 i4的equals方法和集合元素进行比较
    				// 由于 i4是Integer类型,因为Integer覆写了equals方法,所以比较的是值
    				System.out.println(c.contains(i4));
    				
    				Manager m1 = new Manager(2, "张三");
    				Manager m2 = new Manager(2, "张三");
    				c.add(m1);
    				// true , 因为添加了m1,肯定是true
    				System.out.println(c.contains(m1));
    				// false,尽管m1和m2中数据一样,但是会调用equals方法,如果Manager中没有覆写equals方法,
    				// Object中的equals方法会默认比较内存地址,m2和m1的内存地址不同,所以不存在
    				System.out.println(c.contains(m2));
    				
    				// 需求 : 如果编号和姓名一致 就认为是同一个对象
    				// 在Manager中覆写了equals方法之后,再比较 就是true了
    				System.out.println(c.contains(m2));
    				
    	}
    
    }
    class Manager {
    	private int no;
    	private String name;
    
    	@Override
    	public String toString() {
    		return "Manager [no=" + no + ", name=" + name + "]";
    	}
    
    	@Override
    	public boolean equals(Object obj) {
    		System.out.println("=========");
    		if (this == obj) {
    			return true;
    		}
    		if (obj instanceof Manager) {
    			Manager m2 = (Manager) obj;
    			if (this.name.equals(m2.name) && this.no == m2.no) {
    				return true;
    			}
    		}
    		return false;
    	}
    	public int getNo() {
    		return no;
    	}
    
    	public void setNo(int no) {
    		this.no = no;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Manager(int no, String name) {
    		super();
    		this.no = no;
    		this.name = name;
    	}
    
    }
    

    2.Iterator
    Iterator是迭代器,迭代器是一种模式,它可以使序列类型的数据结构的遍历行为和被遍历的对象分离
    我们无需关心该序列底层数据结构是什么,只要拿到这个对象,使用迭代器就可以遍历这个对象的内部数据

    创建迭代器对象
    Iterator it=集合对象.iterator();
    调用集合对象自己的iterator方法可以创建自己的迭代器

    Iterator的方法
    1 boolean hasNext(): 判断光标下一位是否还有元素,有就返回true,没有就返回false,
     生成迭代器的时候,光标不是指向第一个元素的,而是在最顶端,没有指向任何元素,
     光标不会自动复位,使用完之后,必须重新生成
     2 E next():把光标向下移动一位,并返回该位上的数据
     3 remove():删除当前光标指向的元素
     方法使用的顺序是1,2,3
    

    迭代器相当于一个索引器
    迭代器一旦创建,如果集合中添加或者删除元素,那么迭代器必须重新生成,因为个数变了
    否则调用next()方法会报错,但是更改数据不用重新生成
    增强for循环,foreach就是为了让用iterator循环访问的形式变简单,写起来方便,但是需要有删除操作的话还是需要用原来的iterator形式
    forEach也是迭代器,使用forEach和使用iterator一样,不能添加或删除集合数据,但是更改可以
    而普通for和while这种遍历,都是和数据结构存储有关系的,比如数组需要使用arr[index]去访问,可以进行添加和删除操作
    使用迭代器进行遍历时,如果需要删除元素,只能使用迭代器的remove()方法,不能使用集合的remove方法

    public static void main(String[] args) {
              //创建集合
    		Collection c=new ArrayList();
    		//向集合里添加元素
    		//int 自动装箱成Integer类型,然后Integer类型在向上转型成Object类型
    		c.add(12);
    		c.add("as");
    		//double自动装箱成Double类型,然后Double类型在向上转型成Object类型
    		c.add(2.4);
    		c.add(false);
    		c.add(null);
    		//创建迭代器
    		Iterator it=c.iterator();
    		//判断光标的下一位还有没有元素,没有就终止,.hasNext()返回布尔类型的值
    		while(it.hasNext()){
    			//把光标向下移动一位,并返回该位上的值
    			Object o=it.next();
    			System.out.println(o);
    		}
    		//光标已经落在了最后一位,下一位没有元素了
    		// false
    		System.out.println(it.hasNext());
    	    // 如果此时 添加或者删除元素
    		c.add(1);
    		
    		// 只要迭代器生成,集合添加或者删除,再使用这个迭代器就会报错
    		//  java.util.ConcurrentModificationException
    		// 如果要使用迭代器,需要重新生成
    		it=c.iterator();
    		while(it.hasNext()){
    			// 能进来说明有
    			//把光标向下移动一位,并将该位上的数据给到o
    			Object o = it.next();
    			// 生成迭代器不能使用集合的remove,除非重新生成,否则报错
               //c.remove(1);
    			// 但是可以使用迭代器的remove进行删除元素的操作,删除当前光标指向的元素
    			it.remove();
    			System.out.println(o);
    		}
    		// 循环删除完了
    		//输出集合中的元素个数
    		System.out.println(c.size());
    	}
    
    

    3.List

    • List元素的特性 : 有序可重复

    • 存入顺序和取出顺序是一致的,并且有指定的下标可以表示数据的唯一性,所以可以存在重复数据

    • 底层实现

    •  	ArrayList : 底层是数组,查询效率较高,添加和删除效率较低
      
    •  	LinkedList : 底层是双向链表,查询效率较低,添加和删除效率较高
      

    Vector 已经过时了,ArrayList是Vector的升级版,而Vector属于线程安全,ArrayList属于非线程安全,所以ArrayList效率较高

    ArrayList

    public class Collection05 {
         /*ArrayList : 底层索引数组,下标0开始 初始化容量为 10 ,扩大容量为 原始容量的1.5倍.非线程安全,效率高
     * 
     * Vector : 初始化容量为10 , 扩大容量为 原始容量的 2 倍,线程安全,效率低
     * 
     * 所以 Vector已经废弃
     * 
     * List遍历方式
     * 		while , for, foreach , iterator 
     * 
     * add(E e) : 将指定元素添加到尾部
     * add(int index,E e) : 将指定元素添加到指定位置,原位置内容统一向后移动
     * set(int index,E e) : 更改指定位置上的元素值
     * get(int index) : 获取指定索引上的元素
     * remove(int index) : 删除指定索引上的元素
     * remove(Object o) : 删除指定元素
          * */
    	public static void main(String[] args)  {
    		List li = new ArrayList();
    		// 数组中 : 数组只能保存同一数据类型
    		// 集合中 : 可以存储任意类型
    		// 而ArrayList底层又是数组,很简单,因为ArrayList底层是Object[] 数组,  
    		// 同理 我们单独声明Object[]数组的话,也可以说可以存储任意数据
    		// 因为任何数据 都可以转型为Object类型,包括基本(自动装箱再向上转型)
    		
    		// 把数据添加到尾部
    		li.add(1);
    		// 把指定元素,插入到指定位置,该位置上的元素统一向后移动
    		li.add(0, 2);
    		System.out.println(li);
    		// 更改指定位置上的元素
    		li.set(0, 3);
    		System.out.println(li);
    		
    		// 获取指定下标对应的数据
    		Object o = li.get(1);
    		System.out.println(o);
    		
    		// 删除 ,方法重载,如果 是 int 说明是要删除元素的下标是什么, Object 才是被删除的对象
    		
    		// 删除下标为3的元素
    		// li.remove(3);
    		// 删除元素值 为 Integer并且值为3的元素
    		li.remove(new Integer(3));
    		System.out.println(li);
    		
    		li.add("aa");
    		li.add("aa2");
    		li.add("aa3");
    		for (Object object : li) {
    			System.out.println(object);
    		}
    		System.out.println("----");
    		for (int i = 0; i < li.size(); i++) {
    			System.out.println(li.get(i));
    		}
    	}
    
    }
    

    LinkedList

    public class Collection06 {
    //	LinkedList : 底层是双向链表
    //	   		链表 : 链表中保存的是节点,每个节点中有三个元素
    //	   			1 自身对象(添加的元素) , 2 上一个节点的地址 , 3 下一个节点的地址
    //	   链表是没有下标的,内存空间也不是连续的,所以查询比较慢
    //	   		由于内存空间不是连续的,只是保存上下节点的引用,随意添加删除比较快
    //	   
    //	   add(E e) : 添加到尾部
    //	   push(E e) : 添加到头部
    //	   addFirst(E e) : 添加到头部
    //	   addLast(E e) : 添加到尾部
    //	   offerFirst(E e) 添加到头部,成功返回true
    //	   offerLast(E e) : 添加到尾部,成功返回true
    //	   get(int index) : 返回指定下标对应的数据(链表没有下标,只是模拟下标,方便我们查询使用)
    //	   
    //	   本质 就调用了两个方法 : linkLast 和 linkFirst 所以没任何区别
    	public static void main(String[] args) {
    		//底层是双向链表
    		LinkedList linkedList = new LinkedList();
    		//添加到尾部
    		linkedList.add(1);
    		//添加到头部
    		linkedList.addFirst(2);
    		//添加到尾部
    		linkedList.addLast(3);
    		//添加到头部
    		linkedList.push(4);
    		//添加到头部,成功返回true
    		linkedList.offerFirst(5);
    		//添加到尾部,成功返回true
    		linkedList.offerLast(6);
    		//foreach 遍历
    		for (Object object : linkedList) {
    			System.out.println(object);
    		}
    		System.out.println("----");
    		for (int i = 0; i < linkedList.size(); i++) {
    			System.out.println(linkedList.get(i));
    		}
    		
    		// -------- 
    		System.out.println("===");
    		LinkedList linked = new LinkedList();
    		//添加到尾部
    		linked.add("a");
    		linked.add("b");
    		linked.add("c");
    		//输出链表元素个数
    		System.out.println(linked.size());
    		//获取链表指定位置上的元素
    		System.out.println(linked.get(2));
    		
    	}
    
    }
    

    4、Set
    Set元素特点 : 无序不可重复

    • TreeSet : 底层红黑树
    • HashSet : 底层散列表
    public class Collection07 {
    //Set元素特定:无序,不可重复
    	public static void main(String[] args) {
    		Set s = new TreeSet();
    		//添加到尾部
    		s.add(1);
    		s.add(3);
    		//输出集合中元素个数
    		System.out.println(s.size());
    		//Set覆写了toString方法
    		System.out.println(s);
    		//遍历
    		for (Object object : s) {
    			System.out.println(object);
    		}
    	}
    
    }
    

    TreeSet

    • 元素必须有序,添加的元素会按照某种规则自动排序,所以添加元素时需要比较元素,那么注意添加不同类型时会报错

    • 想要使用TreeSet,元素必须要排序
      数字 : 默认从小到大
      字符串 : 默认比较每位ASCII码
      日期 : 默认比较自然日期 昨天-今天-明天

      下面是代码

    public static void main(String[] args) {
    		//创建TreeSet类的对象treeSet
    		TreeSet treeSet = new TreeSet();
    		treeSet.add(1);
    		treeSet.add(3);
    		treeSet.add(2);
    		treeSet.add(7);
    		// 上面是数字,下面如果是字符串就会导致 报错,因为添加的时候需要比较元素大小
    		// 而不同类型 是没有可比性的
    		// treeSet.add("a");
    		for (Object object : treeSet) {
    			System.out.println(object);
    		}
    		System.out.println("----");
    		TreeSet treeSet2 = new TreeSet();
    		treeSet2.add("a");
    		treeSet2.add("1");
    		// 如果有多个字符,先比较第一位,如果第一位不同,则第一位小的在上面
    		// 如果第一位相同,再比较第二位,以此类推
    		treeSet2.add("11");
    		treeSet2.add("101");
    		treeSet2.add("b");
    		treeSet2.add("n");
    		for (Object object : treeSet2) {
    			System.out.println(object);
    		}
    	}
    
    public class Collection09 {
    //	比较器有两种 : 1 元素自身比较器, 2 比较器类
    //	   
    //	  为什么字符串,Integer,Date可以排序?
    //	   		因为都实现了 implements Comparable 
    //	   
    //	   因为使用treeSet在进行数据添加的时候,会自动调用该对象的compareTo()方法和集合内元素进行比较
    //	   
    //	   如果我们想要存储自定义类型怎么办?
    //	   		需要实现comparable接口才行
    	public static void main(String[] args) {
    		TreeSet treeSet = new TreeSet();
    		User user1 = new User(11);
    		User user2 = new User(13);
    		User user3 = new User(6);
    		//添加元素时自动调用User类的compareTo()方法和集合内元素进行比较
    		treeSet.add(user1);
    		treeSet.add(user2);
    		treeSet.add(user3);
    		System.out.println(treeSet.size());
    		
    		for (Object object : treeSet) {
    			System.out.println(object);
    		}
    	}
    
    }
    class User implements Comparable{
    	private int age;
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public User(int age) {
    		super();
    		this.age = age;
    	}
    
    	@Override
    	public String toString() {
    		return "User [age=" + age + "]";
    	}
       
    	//实现Comparable接口覆写compareTo方法
    	@Override
    	public int compareTo(Object o) {
    		// this 是当前对象
    		// o 是集合内对象
    		// 并且 返回值为0 表示 相等,则不添加,set不允许有重复元素
    		// 返回大于0 的 表示 要添加的元素大,则放到后面
    		// 返回小于0 的 表示 要添加的元素小,则放到前面
    
    		User user = (User) o;
    		// 升序
    		return this.age - user.age;
    		// 降序
    		// return this.age - user.age;
    	}
    	
    }
    
    
    展开全文
  • 3.数组中的元素可以是任何数据类型,包括基本类型和引用类型 4.数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存...

    数组

    一、数组概述

    数组的基本特点

    1.其长度是确定的。数组一旦被创建,它的大小就是不可以改变的。2.其元素必须是相同类型,不允许出现混合类型。

    3.数组中的元素可以是任何数据类型,包括基本类型和引用类型

    4.数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

    概述

    数组是一种数据结构,用来存储同一类型值的有序集合

    每一个数据称作一个数据元素,每个数组元素可以通过一个下标来访问它

    二、数组的声明与创建

    1.首先必须声明数组变量,才能在程序中使用数组。

    声明数组:new int [10] 声明了一个长度为10的数组

    2.使用new操作符来创建数组

    变量类型 变量名 = 变量值

    // 动态初始化
    int[] a = new int[10];  // 声明一个长度为10的 a 数组   
    // 静态初始化
    int [] b = {1,2,3,4,5,6}; // 数组的一种简写方式
    

    3.数组长度 :数组名.length

    4.数组中的元素通过索引访问,数组索引自0开始

    如:赋值

    a[0]=1; a[1]=2;

    三、内存分析

    Java内存
    在这里插入图片描述

    截自 遇见狂神说

    四、数组使用

    数组边界

    下标的合法区间为:【0,length-1】,如果越界就会报错

    ArrayIndexOutOfBoundsException :数组下标越界异常

    普通for循环

    public static void main(String[] args) {
        int[] num = {1,2,3,4,5,6};
    
        //遍历for
    
        for (int i = 0; i <num.length ; i++) {
            System.out.println(num[i]);
        }
    
        //计算总和
        int sum = 0;
        for (int i = 0; i < num.length ; i++) {
            sum+=num[i];
        }
        System.out.println("总和为"+sum);
    
        //找出最大值
        int max=0;
        for (int i = 0; i < num.length; i++) {
            if (num[i]>max){
                max=num[i];
            }
            
        }
        System.out.println("最大值为"+max);
    
    }
    

    For-Each 循环

    快捷键:iter 或 数组名.for

    int[] num = {1,2,3,4,5,6};
    
    for (int i : num) {
        System.out.println(i);
    }
    

    数组作为方法入参

    打印数组元素

    public class Demo01 {
    
    
        public static void main(String[] args) {
            int[] num = {1, 2, 3, 4, 5, 6};
    
            Demo01.printArray(num);
    
        }
    
        public static void printArray(int[] num){
            for (int i = 0; i < num.length; i++) {
                System.out.print(num[i]+" ");
    
            }
        }
    
    }
    

    数组作为返回值

    反转数组

    public class Demo01 {
        
        public static void main(String[] args) {
            int[] num = {1, 2, 3, 4, 5, 6};
    
            int[] reverse = Demo01.reverse(num);
            Demo01.printArray(reverse);
    
        }
        // 输出数组
        public static void printArray(int[] num){
            for (int i = 0; i < num.length; i++) {
                System.out.print(num[i]+" ");
    
            }
        }
        //反转数组
        public static int[] reverse( int[] num){
            int[] rssults = new int[num.length];
    
            for (int i = 0 ,j=num.length-1; i <num.length ; i++ ,j--) {
    
                rssults[j]=num[i];
    
            }
    
            return rssults;
        }
    
    }
    

    五、多维数组

    二维数组

    声明:int[][] ints = new int[3][2];

    在这里插入图片描述

    遍历二维数组

    public class  Demo02 {
        public static void main(String[] args) {
            int[][] a ={{1,2},{2,3},{3,4},{4,5}};
            for (int i = 0; i <a.length ; i++) {
                System.out.println();
                for (int j = 0; j < a[i].length; j++) {
                    System.out.print(a[i][j]);
                }
    
            }
        }
    
    }
    

    六、Arrays 类

    七、稀疏数组

    展开全文
  • 2.基本数据类型 3.运算符与表达式 4.数据类型转换 5.字符串类型及相关函数/方法 6.基本输入输出 7. Python常用内置函数 8.注释 (二)流程控制 【考试要求】 掌握Python程序格式框架及书写风格ÿ...
  • 15.6.4 基本类型的特殊化 254 15.7 用于错误和警告的注解 255 练习 256 第16章 XML处理 A2 259 16.1 XML字面量 260 16.2 XML节点 260 16.3 元素属性 262 16.4 内嵌表达式 263 16.5 在属性中使用表达式 264 ...
  • java面试题

    2018-04-27 19:55:38
    int和Integer有什么区别? 答:int是java的原始数据类型,Integer是java为int提供的封装类,java为每个原始数据类型都提供了封装类。 String和StringBuffer的区别?... String不是基本数据类型,引用数据类型。 ...
  • 什么是NoSQL数据库?

    2014-07-21 23:24:20
    可以进行非常快速的保存和读取处理(但无法与memcached相比) 数据不会丢失 两者兼具 Redis属于这种类型。Redis有些特殊,临时性和永久性兼具,且集合了临时性key-value存储和永久性key-value存储的优点。Redis首先...
  • 7.1.2 基本联接类型 7.1.3 其他的联接分类 7.1.4 上一年度的滑动合计 7.1.5 联接算法 7.1.6 拆分元素 7.2 集合运算 7.2.1 UNION 7.2.2 EXCEPT  7.2.3 INTERSECT 7.2.4 集合运算的优先级 7.2.5 在集合运算...
  • 4.学习进阶视频 30天(不用挨个看,详细介绍控件模板属性,可以当做手册查询使用) 入门视频目录 01课程说明.mp4 02.Visual Studio下WPF开发环境的基本使用.mp4 03.Sender是什么.mp4 04复习继承和类型转换.mp4 05.集合...
  • 7.1.2 基本联接类型298 7.1.3 其他的联接分类306 7.1.4 上一年度的滑动合计317 7.1.5 联接算法320 7.1.6 拆分元素326 7.2 集合运算332 7.2.1 UNION332 7.2.2 EXCEPT333 7.2.3 INTERSECT334 7.2.4 集合运算的优先级...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    9.1 面向对象的基本概念.101 9.2 对象的模型技术 .103 9.3 面向对象的分析 .105 9.4 面向对象的设计 .107 9.5 小 结 .110 第十章 类 .112 10.1 类 的 声 明 .112 10.2 类 的 成 员 .113 10.3 构造...
  • 7.1.2 基本联接类型298 7.1.3 其他的联接分类306 7.1.4 上一年度的滑动合计317 7.1.5 联接算法320 7.1.6 拆分元素326 7.2 集合运算332 7.2.1 UNION332 7.2.2 EXCEPT333 7.2.3 INTERSECT334 7.2.4 集合运算的优先级...
  • java面试宝典

    2013-02-28 16:04:01
    3、String 是最基本的数据类型吗? 8 4、float 型float f=3.4是否正确? 8 5、语句float f=1.3;编译能否通过? 8 6、short s1 = 1; s1 = s1 + 1;有什么错? 8 7、Java 有没有goto? 8 8、int 和Integer 有什么区别? 9 9...
  • 7.1.2 基本联接类型298 7.1.3 其他的联接分类306 7.1.4 上一年度的滑动合计317 7.1.5 联接算法320 7.1.6 拆分元素326 7.2 集合运算332 7.2.1 UNION332 7.2.2 EXCEPT333 7.2.3 INTERSECT334 7.2.4 集合运算...
  • C#微软培训资料

    2014-01-22 14:10:17
    9.1 面向对象的基本概念.101 9.2 对象的模型技术 .103 9.3 面向对象的分析 .105 9.4 面向对象的设计 .107 9.5 小 结 .110 第十章 类 .112 10.1 类 的 声 明 .112 10.2 类 的 成 员 .113 10.3 构造...
  • 千方百计笔试题大全

    2011-11-30 21:58:33
    3、String 是最基本的数据类型吗? 8 4、float 型float f=3.4是否正确? 8 5、语句float f=1.3;编译能否通过? 8 6、short s1 = 1; s1 = s1 + 1;有什么错? 8 7、Java 有没有goto? 8 8、int 和Integer 有什么区别? 9 9...
  • 5、String是最基本的数据类型吗?  基本数据类型包括byte、int、char、long、float、double、boolean和short。  java.lang.String类是final类型的,因此不可以继承这个类、不能修改这个类。为了提高效率节省空间,...
  • java 面试题 总结

    2009-09-16 08:45:34
    2、String是最基本的数据类型吗? 基本数据类型包括byte、int、char、long、float、double、boolean和short。 java.lang.String类是final类型的,因此不可以继承这个类、不能修改这个类。为了提高效率节省空间,我们...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    35.java除了8种基本类型外,在虚拟机里还有哪一种,有什么作用? 36.除了使用new关键字创建对象意外,试列举另外三种以上创建实例的方式? 37.classloader中,JDK的API、Classpath中的同web-inf中的class加载方式有...
  • 8.4 集合类型 8.4.5 再论枚举器 8.5 排序 8.6 通用集合库 8.7 新集合 8.7.1 使用 8.7.2 使用 8.7.3 使用 8.7.4 使用 8.7.5 决定实施方案 8.7.6 未支持的操作 8.7.7 排序和搜索 8.7.8 实用工具 8.8 总结 8.9 练习 ...
  • ThinkInJava

    2013-05-28 14:36:27
    8.4 集合类型 8.4.1 Vector 8.4.2 BitSet 8.4.3 Stack 8.4.4 Hashtable 8.4.5 再论枚举器 8.5 排序 8.6 通用集合库 8.7 新集合 8.7.1 使用Collections 8.7.2 使用Lists 8.7.3 使用Sets 8.7.4 使用Maps 8.7.5 决定...
  • Java初学者入门教学

    2012-03-14 21:17:15
    8.4 集合类型 8.4.1 Vector 8.4.2 BitSet 8.4.3 Stack 8.4.4 Hashtable 8.4.5 再论枚举器 8.5 排序 8.6 通用集合库 8.7 新集合 8.7.1 使用Collections 8.7.2 使用Lists 8.7.3 使用Sets 8.7.4 使用Maps 8.7.5 决定...
  • java 编程入门思考

    2012-03-30 17:50:08
    8.4 集合类型 8.4.1 Vector 8.4.2 BitSet 8.4.3 Stack 8.4.4 Hashtable 8.4.5 再论枚举器 8.5 排序 8.6 通用集合库 8.7 新集合 8.7.1 使用Collections 8.7.2 使用Lists 8.7.3 使用Sets 8.7.4 使用Maps 8.7.5 决定...
  • JAVA_Thinking in Java

    2011-12-02 17:58:15
    8.4 集合类型 8.4.1 Vector 8.4.2 BitSet 8.4.3 Stack 8.4.4 Hashtable 8.4.5 再论枚举器 8.5 排序 8.6 通用集合库 8.7 新集合 8.7.1 使用Collections 8.7.2 使用Lists 8.7.3 使用Sets 8.7.4 使用Maps 8.7.5 决定...
  • thinkinjava

    2011-11-30 11:47:28
    8.4 集合类型 8.4.1 Vector 8.4.2 BitSet 8.4.3 Stack 8.4.4 Hashtable 8.4.5 再论枚举器 8.5 排序 8.6 通用集合库 8.7 新集合 8.7.1 使用Collections 8.7.2 使用Lists 8.7.3 使用Sets 8.7.4 使用Maps 8.7.5 决定...
  • 8.4 集合类型 8.4.1 Vector 8.4.2 BitSet 8.4.3 Stack 8.4.4 Hashtable 8.4.5 再论枚举器 8.5 排序 8.6 通用集合库 8.7 新集合 8.7.1 使用Collections 8.7.2 使用Lists 8.7.3 使用Sets 8.7.4 使用Maps 8.7.5 决定...

空空如也

空空如也

1 2 3 4 5 6
收藏数 111
精华内容 44
关键字:

集合可以保存基本类型吗