JAVA基础学习day13--集合一

一、集合的出现

1.1、集合简述

面向对象语言对事物的体现都是以对象形式，为了方便对多个对象的操作，就对象对象进行存储，集合就是存仪储对象最常用的一种试

1.2、数组和集合都是容器

数组也存对象，存储同一种类型，但数组是固定长度的，集合长度是可变。

数组中可以存储基本数据类型，集合只能存储对象

1.3、集合特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

1.4、结构

二、集合共性方法

2.1、Collection接口顶级

Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

2.2、共性方法

方法摘要
boolean add(E e)
确保此 collection 包含指定的元素（可选操作）。
boolean addAll(Collection<? extends E> c)
将指定
collection 中的所有元素都添加到此 collection 中（可选操作）。
void clear()

移除此 collection 中的所有元素（可选操作）。
boolean contains(Object o)

如果此 collection 包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c)

如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean equals(Object o)

比较此 collection 与指定对象是否相等。
int hashCode()

返回此 collection 的哈希码值。
boolean isEmpty()

如果此 collection 不包含元素，则返回 true。
Iterator<E> iterator()

返回在此 collection 的元素上进行迭代的迭代器。
boolean remove(Object o)

从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean removeAll(Collection<?> c)

移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean retainAll(Collection<?> c)

仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int size()

返回此 collection 中的元素数。
Object[] toArray()

返回包含此 collection 中所有元素的数组。
<T>
T[]
toArray(T[] a)

返回包含此 collection
中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

 2.3、ArrayList示例

import java.util.*;

class CollectionDemo {
    public static void main(String[] args) {
        // 声明2个集合容器，并添加元素
        List<String> ar1 = new ArrayList<String>();
        ar1.add("a");
        ar1.add("b");
        ar1.add("c");
        ar1.add("d");
        ar1.add("e");
        // 遍历
        sop("ar1遍历:");
        getIterator(ar1);

        List<String> ar2 = new ArrayList<String>();
        ar2.add("a");
        ar2.add("b");
        ar2.add("f");
        ar2.add("q");
        ar2.add("w");
        // 增强for循环遍历
        sop("ar2遍历:");
        getFor(ar2);

        // 求集合的长度
        sop("ar1的长度:" + ar1.size());
        sop("ar2的长度:" + ar2.size());
        // 比较判断
        sop("ar1中有字符a吗 : " + ar1.contains("a"));
        // 整个集合比较
        sop("ar1中有字符ar2吗 : " + ar1.containsAll(ar2));
        // 求交集
        ar1.retainAll(ar2);
        sop("求交集");
        getFor(ar1);
        // addALL
        ar1.addAll(ar2);
        // 增强for循环遍历
        sop("添加ar2后的ar1:");
        getFor(ar1);

        // 删除
        ar1.remove("c");
        sop("ar1删除指定c后");
        getFor(ar1);
        sop("ar1删除指定集合");
        ar1.removeAll(ar2);
        getFor(ar1);
        sop("ar1是空吗？" + ar1.isEmpty());
        // 清空
        ar1.clear();
        sop(ar1.size());
    }

    // iterator遍历集合
    public static void getIterator(List<String> list) {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            sop(str);
        }
    }

    // forEach遍历
    public static void getFor(List<String> list) {
        for (String str : list) {
            sop(str);
        }
    }

    // 打印
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

结果：

ar1遍历:
a
b
c
d
e
ar2遍历:
a
b
f
q
w
ar1的长度:5
ar2的长度:5
ar1中有字符a吗 : true
ar1中有字符ar2吗 : false
求交集
a
b
添加ar2后的ar1:
a
b
a
b
f
q
w
ar1删除指定c后
a
b
a
b
f
q
w
ar1删除指定集合
ar1是空吗？true
0

2.4、Iterator

方法摘要
boolean hasNext()
如果仍有元素可以迭代，则返回 true。
E next()

返回迭代的下一个元素。
void remove()

从迭代器指向的 collection
中移除迭代器返回的最后一个元素（可选操作）。

 2.5、ArrayList

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

/**
 * List:元素是有序的，元素可以重复，该集合体系有索引
 * Set:元素是无序，元素不可以重复
 * List:
 *         特有方法：可以操作索引的方法都 是特有
 *     add(index ,element)
 * addAll(index,Collection);
 * remove (index)
 * set(index,element)
 * get(index);
 * subList(from,to)
 * listIterator()
 *
 *
 */
public class ListDemo {

    public static void main(String[] args) {
        //add();
        //remove();
        //set();
        //getIndex();
        indexSub();
    }

    //indexOf和subList
    public static void indexSub(){
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java04");
        list.set(2,"hello");
        sop(list.indexOf("java04"));//3
        sop(list.indexOf("java09"));//-1
        sop(list.lastIndexOf("hello"));//2
        List<String> subList=list.subList(1, 3);
        sop(subList);//hello,java03
    }

    //遍历
    public static void getIndex(){
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java04");
        list.set(2,"hello");
        //循环遍历，通过索引的方式遍历和数组一样
        for(int x=0;x<list.size();x++){
            sop("list["+x+"]="+list.get(x));
        }

    }

    //修改
        public static void set(){
            List<String> list=new ArrayList<String>();
            //添加元素
            list.add("java01");
            list.add("java02");
            list.add("java03");
            list.add("java04");
            list.set(2,"hello");
            //遍历
            get(list);
        }
    //删除元素
    public static void remove(){
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java04");
        list.remove(2);
        //遍历
        get(list);
    }

    //添加元素
    public static void add(){
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        //遍历
        get(list);
        //在指定位置添加
        list.add(1,"java09");
        //遍历
        System.out.println("========在指定位置添加后==========");
        get(list);
    }
    //遍历
    public static void get(List<String> list){
        for(Iterator<String> it=list.iterator();it.hasNext();){
            sop(it.next());
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }

}

2.6、列表迭代器 listIterator

iterator，只能做判断、删除、取出，不能做其它操作

listIterator

public ListIterator<E> listIterator(int index)


返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。指定的索引表示 next 的初始调用所返回的第一个元素。previous 方法的初始调用将返回索引比指定索引少 1 的元素。

此实现返回 ListIterator 接口的直接实现，扩展了由 iterator() 方法返回的 Iterator 接口的实现。ListIterator 实现依赖于底层实现列表的 get(int)、set(int, E)、add(int, E) 和 remove(int) 方法。

注意，除非重写列表的 remove(int)、set(int, E) 和 add(int, E) 方法，否则此实现返回的列表迭代器将抛出 UnsupportedOperationException 来响应其 remove、set 和 add 方法。

根据 (protected) modCount 字段规范中的描述，在面临并发修改时，可以使此实现抛出运行时异常。

方法摘要
void add(E e)
将指定的元素插入列表（可选操作）。
boolean hasNext()

以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next
返回一个元素而不是抛出异常，则返回 true）。
boolean hasPrevious()

如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
E next()

返回列表中的下一个元素。
int nextIndex()

返回对 next 的后续调用所返回元素的索引。
E previous()

返回列表中的前一个元素。
int previousIndex()

返回对 previous 的后续调用所返回元素的索引。
void remove()

从列表中移除由 next 或 previous
返回的最后一个元素（可选操作）。
void set(E e)
用指定元素替换
next 或 previous 返回的最后一个元素（可选操作）。		 
package com.pb.list.demo1;

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

public class ListIteratorDemo {

    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java04");
        list.add("java05");
        //获取listIterator迭代器
        ListIterator<String> listIterator=list.listIterator();
        while(listIterator.hasNext()){
            if(listIterator.next().equals("java02")){//判断
                //修改
                listIterator.set("java007");
                //添加
                listIterator.add("hello");
            }

        }
        sop(list);
        //倒序输出遍历
        while(listIterator.hasPrevious()){
            sop(listIterator.previous());
        }

    }
    public static void sop(Object obj){
        System.out.println(obj);

    }

}

2.7、Vector

package com.pb.list.demo1;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;

public class VectorDemo {

    public static void main(String[] args) {
        Vector<String> vector=new Vector<String>();
        //添加元素
        vector.add("java01");
        vector.add("java02");
        vector.add("java03");
        vector.add("java04");
        vector.add("java05");

        //获取枚举
        Enumeration<String> en=vector.elements();
        while(en.hasMoreElements()){
            System.out.println(en.nextElement());
        }

    }

}

2.8、LinkedList

package com.pb.list.demo1;

import java.util.LinkedList;

/**
 * LinkedList特有方法：
 * 添加元素到第一个索引位置 addFirst();
* 添加元素到最后一个索引位置 addLast();
* 获取索引为0的元素 getFirst();
 * 获取索引最后的元素 getLast();
 * 删除索引为0的元素 removeFirst();
 *  删除索引为size()-1的元素 * removeLast();
 */

public class LinkedListDemo {

    public static void main(String[] args) {
        // 声明一个链表集合
        LinkedList<String> list = new LinkedList<String>();
        // 添加到第一个元素
        list.addFirst("1");
        list.add("2");
        list.add("3");
        sop(list);// 3,2,1
        // 将元素添加到最后
        list.addLast("6");
        list.addLast("5");
        list.addLast("4");// 3,2,1,6,5,4
        sop(list);// 获取第一个元素
        sop(list.getFirst());//3
        // 获取最后一个元素
        sop(list.getLast());// 4
        // 删除第一个元素
        sop(list.removeFirst());
        // 删除最后一个
        sop(list.removeLast());
        sop(list);// 2,1,6,5

        /*
         * 获取集合全部元素，不使用迭代器
         */
        while (!list.isEmpty()) {
            list.removeFirst();// list.removeLast();
        }

    }

    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

removeFirst或者removeLast

public E removeFirst()

移除并返回此列表的第一个元素。

指定者：
接口 Deque<E> 中的 removeFirst

返回：

此列表的第一个元素

抛出：

NoSuchElementException - 如果此列表为空

JDK 1.6之后提供了新的方法

pollFirst或者pollLast

public E pollFirst()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

指定者：
接口 Deque<E> 中的 pollFirst
返回：
此列表的第一个元素；如果此列表为空，则返回 null
从以下版本开始：
1.6 

示例

package com.pb.list.demo1;

import java.util.LinkedList;
/**
 * JDK 1.6提供了新的方法
 * offerFirst()，添加元素到第个
 * offerLast(),添加元素到最后一位
 *
 * peekFirst()获取第一个元素
 * peekLast()获取最后一个元素
 *
 * pollFirst()删除第一个元素
 * pollLast()删除最后一个元素
 *
 */
public class LinkedListDemo1 {

    public static void main(String[] args) {

    // 声明一个链表集合
            LinkedList<String> list = new LinkedList<String>();
            // 添加到第一个元素
            list.offerFirst("1");
            list.offerFirst("2");
            list.offerFirst("3");
            sop(list);// 3,21
            // 将元素添加到最后
            list.offerLast("6");
            list.offerLast("5");
            list.offerLast("4");// 3,2,1,6,5,4
            sop(list);
            // 获取第一个元素
            sop(list.peekFirst());// 3
            // 获取最后一个元素
            sop(list.peekLast());// 4
            // 删除第一个元素
            sop(list.pollFirst());
            // 删除最后一个
            sop(list.pollLast());
            sop(list);// 2,1,6,5

            /*
             * 获取集合全部元素，不使用迭代器
             */
            while (!list.isEmpty()) {
                list.pollFirst();// list.pollLast()
            }

        }

        public static void sop(Object obj) {
            System.out.println(obj);
        }

}

示例：

package com.pb.list.demo1;

import java.util.LinkedList;

/**
 * 使用LinkedList模拟一个堆栈或者队列数据结构
 * 堆栈：先进后出
 * 队列：先进先出
 *
 *
 */
public class LinkedListDemo2 {

    public static void main(String[] args) {
        Que q=new Que();
        q.myAdd("java01");
        q.myAdd("java02");
        q.myAdd("java03");
        q.myAdd("java04");
        q.myAdd("java05");
        while(!q.isNUll()){
            //输出
            System.out.println(q.myGet());
        }
    }

}
class Que{
    private LinkedList list=null;
    public Que(){
        list=new LinkedList();

    }

    //判断是不是NULL
    public boolean isNUll(){
        return list.isEmpty();
    }
    //添加
    public void myAdd(Object obj){
        list.offerFirst(obj);
    }
    //删除
    public Object myGet(){
        return list.pollLast(); //先出
        // return list.pollFirst();
    }
}

示例，去除list的重复元素

package com.pb.list.demo1;

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

/**
 * 去除ArrayList中的重复元素
 * @author Administrator
 *
 */
public class ArrayListDemo1 {

    public static void main(String[] args) {
        ArrayList list=new ArrayList();
        list.add("java01");
        list.add("java01");
        list.add("java02");
        list.add("java02");
        list.add("java03");
        list.add("java03");
        list.add("java019");
        System.out.println(getSingle(list));

    }
    public static ArrayList getSingle(ArrayList list){
        ArrayList tempList=new ArrayList();
        for(Iterator it=list.iterator();it.hasNext();){
            Object obj=it.next();
            if(!tempList.contains(obj)){
                tempList.add(obj);
            }
        }

        return tempList;
    }

}

示例，去除list的重复对象

package com.pb.list.demo1;

public class Person {
    private String name;
    private int age;

    //重写equals
    @Override
    public boolean equals(Object obj) {
        if(!(obj instanceof Person)){
            return false;
        }
        Person p=(Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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 void show(){
        System.out.println(this.name+"........"+this.age);
    }
}
package com.pb.list.demo1;

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

/**
 * 去除ArrayList中的重复元素
 * @author Administrator
 *
 */
public class ArrayListDemo1 {

    public static void main(String[] args) {
        Person p1=new Person("张三",19);
        Person p2=new Person("张三",19);
        Person p3=new Person("李四",23);
        Person p4=new Person("李四",23);
        Person p5=new Person("王五",33);
        Person p6=new Person("王五",23);
        Person p7=new Person("赵六",18);

        ArrayList<Person> list=new ArrayList<Person>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);
        list.add(p6);

        //遍历去掉重复后的
        for(Person p:getSingle(list)){
            p.show();
        }

    }
    public static ArrayList<Person> getSingle(ArrayList<Person> list){
        ArrayList<Person> tempList=new ArrayList<Person>();
        for(Iterator<Person> it=list.iterator();it.hasNext();){
            Person p=it.next();
            if(!tempList.contains(p)){ //contains也是调用对象equals方法
                tempList.add(p);
            }

        }

        return tempList;
    }

}

2.9、三种集合区别

ArrayList：底层的数据结构使用是数组结构,遍历快，增、删、改，慢,线程不同步

LinkedList：底层的数据结构使用链表数据结构，遍历慢，增、删、改，快，

Vector:底层的数据结构使用是数组结构,线程同步的，被ArrayList替代了。

三、Set

3.1、List和Set区别

List:元素是有序的，元素可以重复，该集合体系有索引
Set:元素是无序，元素不可以重复

一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。

3.2、常见子类

HashSet--哈希表,TreeSet

3.3、功能方法

Set的方法和Collection一样，使用方式也一样

package com.pb.list.demo1;

public class Person {
    private String name;
    private int age;

    //重写hashCode
    @Override
    public int hashCode() {
        System.out.println("========hashCode");
        return name.hashCode()+age*39;
    }
    //重写equals
    @Override
    public boolean equals(Object obj) {
        if(!(obj instanceof Person)){
            return false;
        }
        Person p=(Person)obj;
        System.out.println(p.name+"========equals"+p.age);
        return this.name.equals(p.name)&&this.age==p.age;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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 void show(){
        System.out.println(this.name+"........"+this.age);
    }
}
package com.pb.list.demo1;

import java.util.HashSet;
import java.util.Iterator;

public class Demo1 {

    public static void main(String[] args) {
        Person p1=new Person("张三",19);
        Person p2=new Person("李四",20);
        Person p3=new Person("张三",19);
        Person p4=new Person("李四",20);
        Person p5=new Person("五一",19);
        Person p6=new Person("五一",19);
        HashSet<Person> set=new HashSet<Person>();
        set.add(p6);
        set.add(p5);
        set.add(p4);
        set.add(p3);
        set.add(p2);
        set.add(p1);
        Iterator<Person> iterator=set.iterator();
        while(iterator.hasNext()){
            Person p=iterator.next();
            p.show();
        }

    }

}
========hashCode
========hashCode
五一========equals19
========hashCode
========hashCode
========hashCode
李四========equals20
========hashCode
张三========equals19
李四........20
张三........19
五一........19

ArrayList:判断元素是否存或者删除依赖的方法equals()方法

Set:判断元素是否存或者删除，依赖的方法hashCode()和equals()方法,先判断hashCode如果有再判断equals

时间： 2024-07-29 01:10:22

JAVA基础学习day13--集合一的相关文章

Java基础学习——数组初识（1）

Java基础学习--数组初识(1) 1什么是数组 Java中常见的一种数据结构就是数组,数组可以分为一维数组.二维数组和多维数组. 数组是由一组相同的变量组成的数据类型,数组中每个元素具有相同的数据类型,数组中的每个元素都可以用一个统一的数组名和下标来确定. 2 数组的使用 数组的一般使用步骤: 声明数组 分配内存给该数组 下面是一维数组为例: 数据类型  数组名 []: 数组名 = new 数据类型 [数据个数]: 2.1一维数组的声明与赋值 1.数组的声明 int  num [];    

JAVA基础学习笔记（2）

看了几天的视频了,都没时间来写下学习笔记,今天来写下第二次的学习笔记,前几天看的给忘记了,就写最新看到的吧 主要内容:1.类的变量与函数(方法) 2.对象的存储方式 3.新建一个对象及对象的赋值与调用 4.空对象 5.匿名对象 1.类的变量与函数(方法) class Dog      //类名 { String name;  //变量的声明 int age; String color; void bark()   //方法的定义(返回值为空,不带参数) { System.out.println(

Java基础学习--抽象类与抽象函数

Java基础学习--抽象类与抽象函数 abstract class 抽象类不能制造对象,但是可以定义变量,赋给这个变量的一定是他非抽象子类的对象: 抽象类中的抽象函数没有函数体,例如:public abstract void move(); 一个抽象类可以没有任何抽象方法,所有的方法都有方法体,但是整个类是抽象的. 抽象类中所有的的抽象函数必需子类的覆盖,而非抽象函数不需要覆盖.因为子类会继承父类的函数,如果不去覆盖继承来的抽象函数,那么子类就含有抽象函数,含有抽象函数的类必须要声明为抽象类.

JAVA基础学习笔记(1)

今天第一天开始学JAVA,时间:2014年6月17日 学习内容:1.java环境的架设 2.JAVA基本数据类型 1.JAVA环境的架设       1.要先去下载JDK,下载地址 2.安装完成后,设置环境变量 1.1环境变量的设置        1.右键-我的电脑-属性-高级-环境变量-系统变量,找到PATH,在里面加入jdk里bin目录的地址 如:c:\java\bin; 2.新建-名为classpath,值为. 1.2测试JAVA是否配置正确        1.在cmd里面输入javac.

Java基础学习总结——Java对象的序列化和反序列化

一.序列化和反序列化的概念 把对象转换为字节序列的过程称为对象的序列化. 把字节序列恢复为对象的过程称为对象的反序列化. 对象的序列化主要有两种用途: 1) 把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中: 2) 在网络上传送对象的字节序列. 在很多应用中,需要对某些对象进行序列化,让它们离开内存空间,入住物理硬盘,以便长期保存.比如最常见的是Web服务器中的Session对象,当有 10万用户并发访问,就有可能出现10万个Session对象,内存可能吃不消,于是Web容器就会把一些s

java基础学习笔记day01

java基础学习笔记day01 1.软件开发: 软件:按照特定顺序组织的计算机数据和指令的集合 开发:软件的制作过程 软件开发:借助开发工具和计算机语言制作软件 2.java概述: java之父:詹姆斯·高斯林 JDK:java开发环境 jre:java运行环境 JVM:java虚拟机 java跨平台是因为,JVM能在不同的平台运行,JVM是跨平台的 JavaSE:标准版 JavaME:手机端,物联网 JavaEE:企业版,互联网项目 3.java语言特点: 简单性 解释性 面向对象 高性能 分

Java基础学习1-Java标识符及基本类型

暑假闲来无事,重新学习Java,希望能够加深自己对Java的理解与深入. 第一天,从Java标识符开始. Java标识符的命名规则 - 标识符必须以字母.下划线.美元符$开头. - 标识符其它部分可以是字母.下划线.美元符$和数字的任意组合. - Java标识符的大小写敏感,无长度限制(但是也不要太长,会变成裹脚布的(/ □ \)). - 不可以是Java的关键字(这点只要是有点基础的都会知道啦,Java的关键字还挺多的哦,小心踩到地雷呀). 下面是一个小栗子. /* *测试标识符的写法 */

转载:java基础学习总结——java读取properties文件总结

java基础学习总结--java读取properties文件总结 一.java读取properties文件总结 在java项目中,操作properties文件是经常要做的,因为很多的配置信息都会写在properties文件中,这里主要是总结使用getResourceAsStream方法和InputStream流去读取properties文件,使用getResourceAsStream方法去读取properties文件时需要特别注意properties文件路径的写法,测试项目如下: 1.1.项目的

java基础学习总结——java环境变量配置(转)

java基础学习总结——java环境变量配置 前言 学习java的第一步就要搭建java的学习环境,首先是要安装 JDK,JDK安装好之后,还需要在电脑上配置"JAVA_HOME”."path”."classpath"这三个环境变量才能够把java的开发环境 搭建好.在没安装过jdk的环境下,path环境变量是系统变量,本来存在的,而JAVA_HOME和classpath是不存在的. 一.配置JAVA_HOME变量 操作步骤(win7系统):计算机→右键“属性”→高

java基础学习-变量&运算

package com.J; public class java { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub float a=1.11111111111111f;    // 数据表示单精度末尾+"f",此处数据存储要溢出 double b=1.1111111111111111;  // java里面默认小数都为double双精度浮点