基本数据类型对象包装类

最新推荐文章于 2022-05-08 16:55:02 发布
最新推荐文章于 2022-05-08 16:55:02 发布
阅读量86 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoxixuewu/article/details/100071353
版权 

public static void main(String[] args) {
		//将整数类型转换为字符串类型。
		int a = Integer.parseInt("123");
		sop("a="+a);
		sop("a="+(a+4));//结果为127

	}
	public static void sop(String str) {
		System.out.println(str);
	}
}

集合框架(类):

public static void main(String[] args) {
		//创建一个集合容器，使用collection接口的子类，ArrayList
		ArrayList al = new ArrayList();
		//01添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		sop(al);//02打印元素
		//03获取合数，集合长度。
		sop(al.size());
		sop(al.remove("java01"));//04删除一个。claer全部删除
		//05判断元素
		sop("java02是否存在："+al.contains("java02"));
		sop(al.isEmpty());//判断集合是否为空

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

List集合共性方法：

public static void main(String[] args) {		
		ArrayList al = new ArrayList();	
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add(1,"java04");//指定位置添加元素。
		sop(al);
		//al.remove(2);//指定位置删除元素
		al.set(0, "java001");//修改指定位置的元素
		sop(al.get(1));//获取指定位置的元素
		sop(al);
		//获取所有元素
		for(int x = 0;x < al.size();x++) {
			System.out.println("al["+x+"]="+al.get(x));
		}
	}
	public static void sop(Object obj) {
		System.out.println(obj);
	}
}


 

public static void main(String[] args) {		
		ArrayList al = new ArrayList();	
		al.add("java01");
		al.add("java02");
		al.add("java03");
		sop(al);
		ListIterator li = al.listIterator();
		while(li.hasNext()) {
			Object obj = li.next();
			if(obj.equals("java02")) {
				li.set("java006");
			}
		}
		while(li.hasPrevious()) {//hasNext正向取
			sop("pre::"+li.previous());
		}
		sop(al);
		
	}
	public static void sop(Object obj) {
		System.out.println(obj);
	}
}

vector中的枚举：

public class VectorDemo {
	/*枚举就是Vector特有的取出方式，发现枚举和迭代很像。其实一样。
	 * 
	 * */

	public static void main(String[] args) {
		Vector v = new Vector();
		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");
		Enumeration en = v.elements();
		while(en.hasMoreElements()) {
			System.out.println(en.nextElement());
		}
	}
}

LinkedList：

public static void main(String[] args) {
		LinkedList link = new LinkedList();
		link.add("java01");
		link.add("java02");
		link.add("java03");
		link.add("java04");
		//sop(link.getFirst());
		//sop(link.removeFirst());
		while(!link.isEmpty()) {//移动第一个遍历字符串
			sop(link.removeFirst());
		}
	}
	public static void sop(Object obj) {
		System.out.println(obj);
	}
}

练习：

public static void main(String[] args) {
		DuiLie dl = new DuiLie();
		dl.MyAdd("java01");
		dl.MyAdd("java02");
		dl.MyAdd("java03");
		dl.MyAdd("java04");
		while(!dl.isNull()) {
			System.out.println(dl.myGet());
		}	
	}
}
class DuiLie{
	private LinkedList link;
	DuiLie(){
		link = new LinkedList();
	}
	public void MyAdd(Object obj) {
		link.addFirst(obj);
	}
	public Object myGet() {
		return link.removeFirst();
	}
	public boolean isNull() {
		return link.isEmpty();
	}
}

去除ArrayList中重复的元素：

  1. 	public static void main(String[] args) {
		
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java03");
		sop(al);                         Iterator it = al.iterator();//在迭代时循环中Next只能调用一次，就要hasNext判断一次。会出现找不到元素异常。
		al = singleElement(al);          while(it.hasNext()){
                                              sop(it.next()+" ..."+it.next());
                                                }
		sop(al);
	}
	public static void sop(Object obj) {
		System.out.println(obj);
	}	
	public static ArrayList singleElement(ArrayList al) {
		ArrayList newAl = new ArrayList();//新建一个容器。
		Iterator it = al.iterator();//遍历集合元素。
		while(it.hasNext()) {
			Object obj = it.next();
			if(!newAl.contains(obj)) 
				newAl.add(obj);					
		}
		return newAl;			
	}
}

List人练习：

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

	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		al.add(new Person("lisi01",10));//al.add(Object obj) == Object obj=new Person("lisi01",10)
		al.add(new Person("lisi02",20));
		al.add(new Person("lisi03",30));
		al.add(new Person("lisi03",30));
		al=singleElement(al);
		Iterator it = al.iterator();
		while(it.hasNext()) {
			Person p = (Person)it.next();
			sop(p.getName()+"..."+p.getAge());
		}
	}
	public static ArrayList singleElement(ArrayList al) {
		ArrayList newAl = new ArrayList();//新建一个容器。
		Iterator it = al.iterator();//遍历集合元素。
		while(it.hasNext()) {
			Object obj = it.next();
			if(!newAl.contains(obj)) 
				newAl.add(obj);					
		}
		return newAl;			
	}
	
}
class Person{
	private String name;
	private int age;
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public boolean equals(Object obj) {
		if(!(obj instanceof Person)) {
			return false;
		}
		Person p = (Person)obj;
		//System.out.println(this.name+"..."+p.age);
		return this.name.equals(p.name) && this.age == p.age;
	}
	public void setName(String n) {
		name = n;
	}
	public String getName() {
		return name;
	}
	public void setAge(int a) {
		age = a;
	}
	public int getAge() {
		return age;
	}
}

2.HashSet：元素是无序的（存入和取出的不一定一致）元素不可以重复

2.1HashSet  底层数据结构是哈希表

2.2TreeSet

Set集合的功能和collection是一致的

public static void main(String[] args) {
		HashSet hs = new HashSet();
		sop(hs.add("java01"));
		sop(hs.add("java01"));
		hs.add("java01");
		hs.add("java02");
		hs.add("java03");
		hs.add("java04");
		Iterator it = hs.iterator();
		while(it.hasNext()) {
			sop(it.next());
		}
	}
	public static void sop(Object obj) {
		System.out.println(obj);
	}
}

无序并且不重复

public static void main(String[] args) {
		HashSet hs = new HashSet();		
		hs.add(new Person1("java01",11));
		hs.add(new Person1("java02",12));
		hs.add(new Person1("java03",13));	
		hs.add(new Person1("java03",13));
		Iterator it = hs.iterator();
		while(it.hasNext()) {
			Person1 p = (Person1)it.next();
			sop(p.getName()+"..."+p.getAge());
		}
	}
	public static void sop(Object obj) {
		System.out.println(obj);
	}
}
class Person1{
	private String name;
	private int age;
	Person1(String name,int age){
		this.name = name;
		this.age = age;
	}
	public int hashCode() {
		System.out.println(this.name+"...+hashCode");
		return name.hashCode()+age;
	}
	public boolean equals(Object obj) {
		if(!(obj instanceof Person1)) {
			return false;
		}
		Person1 p = (Person1)obj;
		System.out.println(this.name+"..equals.."+p.name);
		return this.name.equals(p.name) && this.age == p.age;
	}
	public void setName(String n) {
		name = n;
	}
	public String getName() {
		return name;
	}
	public void setAge(int a) {
		age = a;
	}
	public int getAge() {
		return age;
	}
}

会自动去除相同的元素，如果主要条件相同一定要判断一下次要条件。

创建学生对象存储按照学生年龄进行排序

public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi01",12));
		ts.add(new Student("lisi03",14));
		ts.add(new Student("lisi02",13));	
		ts.add(new Student("lisi04",13));
		Iterator it =ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}	
}
 class Student implements Comparable{//该接口强制让学生具有比较行
	private String name;
	private int age;
	Student(String name,int age){
		this.name=name;
		this.age=age;		
	}
	public int compareTo(Object obj) {
//return -1;//return 0只存进去一个元素，-1是反着取，1是正着取出。
		if(!(obj instanceof Student)) 
			throw new RuntimeException("不是学生对象");		
		Student s = (Student)obj;
		System.out.println(this.name+"..compareTO"+s.name);
		if(this.age > s.age)
		{return 1;}
		if(this.age==s.age)
			{return this.name.compareTo(s.name);}//如果年龄相同增加比较姓名是否相同
			return -1;
	}
	public void setName(String n) {
		name=n;
	}
	public String getName() {
		return name;
	}
	public void setAge(int a) {
		age=a;
	}
	public int getAge() {
		return age;
	}	
}

 

public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi01",12));
		ts.add(new Student("lisi05",12));
		ts.add(new Student("lisi03",14));
		ts.add(new Student("lisi02",13));	
		ts.add(new Student("lisi04",13));
		Iterator it =ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}	
}
 class Student implements Comparable{//该接口强制让学生具有比较行
	private String name;
	private int age;
	Student(String name,int age){
		this.name=name;
		this.age=age;		
	}
	public int compareTo(Object obj) {		
		if(!(obj instanceof Student)) 
			throw new RuntimeException("不是学生对象");		
		Student s = (Student)obj;
		//System.out.println(this.name+"..compareTO"+s.name);
		if(this.age > s.age)
		{return 1;}
		if(this.age==s.age)
			{return this.name.compareTo(s.name);}//如果年龄相同增加比较姓名是否相同
			return -1;
	}
	public void setName(String n) {
		name=n;
	}
	public String getName() {
		return name;
	}
	public void setAge(int a) {
		age=a;
	}
	public int getAge() {
		return age;
	}	
}
class MyCompare implements Comparator{
	public int compare(Object o1,Object o2) {
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;
		int num = s1.getName().compareTo(s2.getName());
		if(num==0) {
			return new Integer(s1.getAge()).compareTo(s2.getAge());
//			if(s1.getAge()>s2.getAge()) 
//				return 1;
//			if(s1.getAge()==s2.getAge())
//				return 0;	
//			return 1;
		}
		return num;
	}
}

练习：

public static void main(String[] args) {
		TreeSet st = new TreeSet(new StrLenComparator());
		st.add("a");
		st.add("ab");
		st.add("dca");
		st.add("aaa");
		st.add("ddef");
		Iterator it = st.iterator();//迭代器
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}
class StrLenComparator implements Comparator{
	public int compare(Object o1,Object o2) {
		String s1 = (String)o1;
		String s2 = (String)o2;
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num==0) //如果不加判断会出现aaa不打印的现象。
			return s1.compareTo(s2);
		
		return num;
	}
}

泛型

public static void main(String[] args) {
		TreeSet<String> ts = new TreeSet<String>(new LenComparator());
		ts.add("aa");
		ts.add("bbc");
		ts.add("a");
		ts.add("abc");
		ts.add("ewrwer");
		Iterator<String> it = ts.iterator();
		while(it.hasNext()) {
			String s= it.next();
			System.out.println(s);
		}
	}
}
class LenComparator implements Comparator<String>{
	public int compare(String o1,String o2) {
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		if(num==0)
			return o1.compareTo(o2);
			return num;
	}
}

15-12

 

 

 

 

 

 

 

 

 

xiaoxixuewu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基本数据类型包装类
七一
07-05 132
基本数据类型包装类 在java中有一切皆对象，java中基本数据类型就不符合这种设计思想，因为八种基本数据类型并不是引用数据类型，所以java中为了解决这样的问题，JDK1.5后引入了八种基本数据类型的包装类。 八种包装类分为两大类型： Number： Integer，Short，Long，Double，Float，Byte都是Number的子类表示是一个数字 Object：Character，Boolean都是Object的直接子类 package com.lili.packClass; /**
基本数据类型及其包装类
weixin_41704733的博客
04-07 178
之前的文章，可能完全出于笔记，或者记录而言，并没有带着分享的心得去写，有一些内容笔记知识点写的不够全面，希望读者可以多给点建议，这次我也总结下基本数据类型及其包装类这一刻的内容，查阅了网上资料，大家可以了解下，翻翻看。 一　基本数据类型的系统描述： 总述：Java基本数据类型分为两大类：boolean类型和数值类型。数值类型可分为整数类型和浮点类型，而其中字符类型可单独对待。所以Ja...
16-11-Java常用类之包装类【干货笔记】
助你成为一名优秀的全栈工程师！
07-28 194
文章目录1、包装类1.1、基本数据类型对应的包装类型（java.lang包）：2、装箱/拆箱3、自动装箱/自动拆箱4、基本类型与字符串之间的转换5、面试相关5.1、下面这段代码的输出结果是什么？5.2、下面这段代码的输出结果是什么？5.3、下面这段代码输出结果是什么？5.4、谈谈Integer i = new Integer(xxx)和Integer i =xxx;这两种方式的区别。5.5、下面程序的输出结果是什么？ 1、包装类 java.lang包中。基本类型数据使用方便，效率高。但是没有对应方法操作它。
基本数据类型和包装类型
Leon_Jinhai_Sun的博客
02-25 203
1、包装类是对象，拥有方法和字段，对象的调用都是通过引用对象的地址；基本类型不是 2、包装类型是引用的传递；基本类型是值的传递 3、声明方式不同： 基本数据类型不需要new关键字； 包装类型需要new在堆内存中进行new来分配内存空间 4、存储位置不同： 基本数据类型直接将值保存在值栈中； 包装类型是把对象放在堆中，然后通过对象的引用来调用他们 5、初...
java基础（十）基本数据类型和其包装类
Carol_kit的博客
07-09 235
1.1 引言 基本数据类型不是对象，但是可以使用Java API将其包装成对象。 出于对性能的考虑，在Java中基本数据类型不作为对象使用。因为处理对象需要额外的系统开销，会带来很多负面影响，然而Java中的许多方法需要将对象作为参数，为此，Java提供了一个方便的方法，即将基本数据类型合并或者说包装成对象。 int——Integer、double——Double、char——Charact...
基本数据类型包装类.pdf
09-06
基本数据类型包装类是 Java 语言中的一种机制，用于将基本数据类型封装成对象。这些对象可以被存储在集合中、作为方法的参数、返回值等。在 Java 中，基本数据类型包装类包括 Byte、Short、Integer、Long、Character...
Java基本数据类型包装类原理解析
08-19
包装类的使用有很多优点，例如可以将基本数据类型的值转换为对象，然后使用对象的方法来操作基本数据类型的值，或者将对象转换回基本数据类型的值。这样可以方便地在基本数据类型和对象之间进行转换，提高程序的灵活...
Java 基本数据类型包装类
08-10
这些基本数据类型不能直接作为对象来操作，但Java为了方便处理，为每种基本数据类型提供了对应的包装类，比如Integer、Double、Character和Boolean等。这些包装类是对象，它们封装了基本数据类型，并提供了丰富的...
Java基本数据类型与对应的包装类(动力节点java学院整理)
08-30
Java语言的面向对象特性在设计时考虑了各种数据类型的封装，从而诞生了基本数据类型对应的包装类。这些包装类使得基本类型能够与面向对象的概念更好地融合，提供了更多的功能和便利。下面将详细介绍Java中的基本数据...
Java基础教程之基本类型数据类型、包装类及自动拆装箱
08-25
将包装类转为基本数据类型的过程叫“拆箱”。例如： ```java public static void main(String[] args) { Integer a = 0; for(int i = 0; i ; i++){ a += i; } } ``` 上面的代码将基本类型数据类型int转换为包装...
16-01-常用对象API(基本数据类型对象包装类-概述)
wy_0928的博客
08-11 335
package cn.itcast.wrapper; public class WrapperDemo { public static void main(String[] args) { /* * 基本数据类型对象包装类 * 为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。 * 用于描述该对象的类就称为基本数据类型对象包装类
Java基础——基本数据类型的包装类
Gray_Wolfs的博客
08-05 331
一、 包装类 java中的数据类型int，double等不是对象，无法通过向上转型获取到Object提供的方法，而像String却可以，只因为String是一个对象而不是一个类型。基本数据类型由于这样的特性，导致无法参与转型，泛型，反射等过程。为了弥补这个缺陷，java提供了包装类。 包装类顾名思义就是将基本的数据类型以及一些辅助方法包装到类中，例如自己实现一个int的包装类： class I...
Java中的~基本类型包装类
java面试笔试
06-07 1669
今天我们来一起聊聊基本类型的包装类我们在学习 Java 的时候有了解Java有四类八种基本数据类型这些基本数据类型都有对应的包装类基本类型的包装类基本类型包装类的概述将基...
JAVA基础编程——基本数据类型的包装类
止步听风的博客
05-08 1776
JAVA中的基本实际原则就是“一切皆对象”。而基本数据类型很显然不是对象，因此可以采用基本数据类型进行包装。 JAVA给出了一组包装类，分别为Byte、Short、Integer、Long、Float、Double、Character、Boolean，对应不同的基本数据类型。 上面的包装类又可以分为两种子类型： 对象型包装类(Object直接子类)：Character、Boolean 数值型包装类(Number直接子类)：Byte、Short、Integer、Long、Float、Double Nu
javaApI_基本数据类型以及其包装类
ahow81212的博客
12-28 155
基本数据类型以及其包装类 1.概述 在程序中，我们知道一些数据类型，如int ,float double等可以表示不同类型的数据，但是呢，有时候这一些数据的操作，表示，以及扩展还是 不够，所以java针对每一种数据类型，给出了其对应的类类型。简称包装类类型。 2.创建的基本类型以及其包装类类型 byte ----->Byte short ----->Sh...
JAVA基础（基本数据类型的包装类）
huicoker的博客
08-08 121
一，拆箱与装箱 二，基本数据类型的转换
条件判断语句
xiaoxixuewu的博客
07-14 1549
条件判断三种形式： 1)三元运算符 2）if-else 3）switch 1.三元运算符 1)公式：(条件表达式)？表达式1：表达式2； 如果条件true，运算后的结果表达式1，如果条件false，运算结果表达式2； 返回的结果只有true和false（其实就是if else条件判断语句） 2)使用三元运算符的好处：简化if-else的形式。弊端：因为是一...
函数与数组
xiaoxixuewu的博客
07-17 848
函数的定义和调用 1.认识函数 1）函数定义：就是封装了一个功能的方法。函数又叫方法。 2）函数的格式 参数类型：是形式参数的数据类型。 形式参数：是一个变量，用于存储调用函数是传递给参数的实际参数。 实际参数：传递给形式参数的具体数值。 如果函数没有返回值，格式是： public void test(int a){ ...... //不需要return...
final关键字和接口interface
xiaoxixuewu的博客
08-01 663
作为常量：常量的书写规范所有字母都大写，如果由多个单词组成单词间通过“_”连接 三： public static void main(String[] args) { //new BaseStudent().study(); new Student().study(); } } class Student{ void study() { } } class ...
java基本数据类型及包装类
最新发布
06-12
包装类是一种将基本数据类型转换为对象的方式，包装类的命名与基本数据类型的命名相同，只是首字母大写。Java提供了8种基本数据类型对应的包装类，分别是： 1. Byte 2. Short 3. Integer 4. Long 5. Float 6. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值