精华内容
下载资源
问答
  • java包装类用法举例

    2020-03-05 22:57:43
    包装类用法举例 基本数据类型的包装类主要用于字符串和基本数据类型的转换。 Integer i1=222;//(包装类) int类型的自动装箱 Float j1=22.33 float类型的自动装箱 int i2=i1;//自动拆箱 // 字符串转基本数据...

    包装类用法举例

    基本数据类型的包装类主要用于字符串和基本数据类型的转换。

    Integer i1=222;//(包装类)   int类型的自动装箱    Float j1=22.33 float类型的自动装箱
        int i2=i1;//自动拆箱
        
    
    //    字符串转基本数据类型
        int i=Integer.parseInt("22333");
        float j=Float.parseFloat("22.333");
        boolean k=Boolean.parseBoolean("true");
            System.out.println(i);
            System.out.println(j);
            System.out.println(k);
    
    //    基本数据类型转字符串
    String istr=String.valueOf(i);
    String fstr =String.valueOf(j);
            System.out.println(istr);
            System.out.println(fstr);
    }
    
    

    运行结果
    22333 int类型
    22.333 float类型
    true boolean类型
    22333 String类型
    22.333 String类型

    父类的toString方法就是输出当前对象的内存地址

     MyDate m1=new MyDate(2019,10,8);
            System.out.println(m1.toString());
    
    运行结果
    b.MyDate@2d98a335
    
    展开全文
  • 主要介绍了Java基本类型包装类概述与Integer类、Character类用法,结合实例形式分析了java基本数据类型与字符串转换相关操作技巧,需要的朋友可以参考下
  • 本文实例讲述了Java基本类型包装类概述与Integer类、Character类用法。分享给大家供大家参考,具体如下:基本类型包装类概述将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。常用的...

    本文实例讲述了Java基本类型包装类概述与Integer类、Character类用法。分享给大家供大家参考,具体如下:

    基本类型包装类概述

    将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。

    常用的操作之一:用于基本数据类型与字符串之间的转换。

    基本类型和包装类的对应

    Byte,Short,Integer,Long,Float,Double,Character,Boolean

    Integer类

    为了让基本类型的数据进行更多的操作,Java就为每种基本类型提供了对应的包装类类型

    package cn.itcast_01;

    /*

    * 需求1:我要求大家把100这个数据的二进制,八进制,十六进制计算出来

    * 需求2:我要求大家判断一个数据是否是int范围内的。

    * 首先你的知道int的范围是多大?

    *

    * 为了对基本数据类型进行更多的操作,更方便的操作,Java就针对每一种基本数据类型提供了对应的类类型。包装类类型。

    * byte Byte

    * short Short

    * int Integer

    * long Long

    * float Float

    * double Double

    * char Character

    * boolean Boolean

    *

    * 用于基本数据类型与字符串之间的转换。

    */

    public class IntegerDemo {

    public static void main(String[] args) {

    // 不麻烦的就来了

    // public static String toBinaryString(int i)

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

    // public static String toOctalString(int i)

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

    // public static String toHexString(int i)

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

    // public static final int MAX_VALUE

    System.out.println(Integer.MAX_VALUE);

    // public static final int MIN_VALUE

    System.out.println(Integer.MIN_VALUE);

    }

    }

    Integer的构造方法

    package cn.itcast_02;

    /*

    * Integer的构造方法:

    * public Integer(int value)

    * public Integer(String s)

    * 注意:这个字符串必须是由数字字符组成

    */

    public class IntegerDemo {

    public static void main(String[] args) {

    // 方式1

    int i = 100;

    Integer ii = new Integer(i);

    System.out.println("ii:" + ii);

    // 方式2

    String s = "100";

    // NumberFormatException

    // String s = "abc";//这个字符串必须是由数字字符组成

    Integer iii = new Integer(s);

    System.out.println("iii:" + iii);

    }

    }

    String和int的相互转换

    package cn.itcast_03;

    /*

    * int类型和String类型的相互转换

    *

    * int -- String

    * String.valueOf(number)

    *

    * String -- int

    * Integer.parseInt(s)

    */

    public class IntegerDemo {

    public static void main(String[] args) {

    // int -- String

    int number = 100;

    // 方式1

    String s1 = "" + number;

    System.out.println("s1:" + s1);

    // 方式2

    String s2 = String.valueOf(number);

    System.out.println("s2:" + s2);

    // 方式3

    // int -- Integer -- String

    Integer i = new Integer(number);

    String s3 = i.toString();

    System.out.println("s3:" + s3);

    // 方式4

    // public static String toString(int i)

    String s4 = Integer.toString(number);

    System.out.println("s4:" + s4);

    System.out.println("-----------------");

    // String -- int

    String s = "100";

    // 方式1

    // String -- Integer -- int

    Integer ii = new Integer(s);

    // public int intValue()

    int x = ii.intValue();

    System.out.println("x:" + x);

    //方式2

    //public static int parseInt(String s)

    int y = Integer.parseInt(s);

    System.out.println("y:"+y);

    }

    }

    Integer的进制转换的操作

    package cn.itcast_04;

    /*

    * 常用的基本进制转换

    * public static String toBinaryString(int i)

    * public static String toOctalString(int i)

    * public static String toHexString(int i)

    *

    * 十进制到其他进制

    * public static String toString(int i,int radix)

    * 由这个我们也看到了进制的范围:2-36

    * 为什么呢?0,...9,a...z,加起来36个

    *

    * 其他进制到十进制

    * public static int parseInt(String s,int radix)

    */

    public class IntegerDemo {

    public static void main(String[] args) {

    // 十进制到二进制,八进制,十六进制

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

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

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

    System.out.println("-------------------------");

    // 十进制到其他进制

    System.out.println(Integer.toString(100, 10));

    System.out.println(Integer.toString(100, 2));

    System.out.println(Integer.toString(100, 8));

    System.out.println(Integer.toString(100, 16));

    System.out.println(Integer.toString(100, 5));

    System.out.println(Integer.toString(100, 7));

    System.out.println(Integer.toString(100, -7));

    System.out.println(Integer.toString(100, 70));

    System.out.println(Integer.toString(100, 1));

    System.out.println(Integer.toString(100, 17));

    System.out.println(Integer.toString(100, 32));

    System.out.println(Integer.toString(100, 37));

    System.out.println(Integer.toString(100, 36));

    System.out.println("-------------------------");

    //其他进制到十进制

    System.out.println(Integer.parseInt("100", 10));

    System.out.println(Integer.parseInt("100", 2));

    System.out.println(Integer.parseInt("100", 8));

    System.out.println(Integer.parseInt("100", 16));

    System.out.println(Integer.parseInt("100", 23));

    //NumberFormatException

    //System.out.println(Integer.parseInt("123", 2));

    }

    }

    JDK5的新特性--自动装箱和自动拆箱

    package cn.itcast_05;

    /*

    * JDK5的新特性

    * 自动装箱:把基本类型转换为包装类类型

    * 自动拆箱:把包装类类型转换为基本类型

    *

    * 注意一个小问题:

    * 在使用时,Integer x = null;代码就会出现NullPointerException。

    * 建议先判断是否为null,然后再使用。

    */

    public class IntegerDemo {

    public static void main(String[] args) {

    // 定义了一个int类型的包装类类型变量i

    // Integer i = new Integer(100);

    Integer ii = 100;

    ii += 200;

    System.out.println("ii:" + ii);

    // 通过反编译后的代码

    // Integer ii = Integer.valueOf(100); //自动装箱

    // ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱,再自动装箱

    // System.out.println((new StringBuilder("ii:")).append(ii).toString());

    Integer iii = null;

    // NullPointerException,如果iii为空对象,会报错,需要判断是否为空

    if (iii != null) {

    iii += 1000;

    System.out.println(iii);

    }

    }

    }

    -128到127之间的数据缓冲池问题

    package cn.itcast_06;

    /*

    * 看程序写结果

    *

    * 注意:Integer的数据直接赋值,如果在-128到127之间,会直接从缓冲池里获取数据

    */

    public class IntegerDemo {

    public static void main(String[] args) {

    Integer i1 = new Integer(127);

    Integer i2 = new Integer(127);

    System.out.println(i1 == i2);

    System.out.println(i1.equals(i2));

    System.out.println("-----------");

    Integer i3 = new Integer(128);

    Integer i4 = new Integer(128);

    System.out.println(i3 == i4);

    System.out.println(i3.equals(i4));

    System.out.println("-----------");

    Integer i5 = 128;

    Integer i6 = 128;

    System.out.println(i5 == i6);

    System.out.println(i5.equals(i6));

    System.out.println("-----------");

    Integer i7 = 127;

    Integer i8 = 127;

    System.out.println(i7 == i8);//true

    System.out.println(i7.equals(i8));

    // 通过查看源码,我们就知道了,针对-128到127之间的数据,做了一个数据缓冲池,如果数据是该范围内的,每次并不创建新的空间

    // Integer ii = Integer.valueOf(127);

    }

    }

    Character

    Character 类在对象中包装一个基本类型 char 的值

    package cn.itcast_01;

    /*

    * Character 类在对象中包装一个基本类型 char 的值

    * 此外,该类提供了几种方法,以确定字符的类别(小写字母,数字,等等),并将字符从大写转换成小写,反之亦然

    *

    * 构造方法:

    * Character(char value)

    */

    public class CharacterDemo {

    public static void main(String[] args) {

    // 创建对象

    // Character ch = new Character((char) 97);

    Character ch = new Character('a');

    System.out.println("ch:" + ch);

    }

    }

    Character 类,常见方法。

    确定字符的类别(小写字母,数字,等等),并将字符从大写转换成小写

    package cn.itcast_02;

    /*

    * public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符

    * public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符

    * public static boolean isDigit(char ch):判断给定的字符是否是数字字符

    * public static char toUpperCase(char ch):把给定的字符转换为大写字符

    * public static char toLowerCase(char ch):把给定的字符转换为小写字符

    */

    public class CharacterDemo {

    public static void main(String[] args) {

    // public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符

    System.out.println("isUpperCase:" + Character.isUpperCase('A'));

    System.out.println("isUpperCase:" + Character.isUpperCase('a'));

    System.out.println("isUpperCase:" + Character.isUpperCase('0'));

    System.out.println("-----------------------------------------");

    // public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符

    System.out.println("isLowerCase:" + Character.isLowerCase('A'));

    System.out.println("isLowerCase:" + Character.isLowerCase('a'));

    System.out.println("isLowerCase:" + Character.isLowerCase('0'));

    System.out.println("-----------------------------------------");

    // public static boolean isDigit(char ch):判断给定的字符是否是数字字符

    System.out.println("isDigit:" + Character.isDigit('A'));

    System.out.println("isDigit:" + Character.isDigit('a'));

    System.out.println("isDigit:" + Character.isDigit('0'));

    System.out.println("-----------------------------------------");

    // public static char toUpperCase(char ch):把给定的字符转换为大写字符

    System.out.println("toUpperCase:" + Character.toUpperCase('A'));

    System.out.println("toUpperCase:" + Character.toUpperCase('a'));

    System.out.println("-----------------------------------------");

    // public static char toLowerCase(char ch):把给定的字符转换为小写字符

    System.out.println("toLowerCase:" + Character.toLowerCase('A'));

    System.out.println("toLowerCase:" + Character.toLowerCase('a'));

    }

    }

    统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数

    package cn.itcast_03;

    import java.util.Scanner;

    /*

    * 统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)

    *

    * 分析:

    * A:定义三个统计变量。

    * int bigCont=0;

    * int smalCount=0;

    * int numberCount=0;

    * B:键盘录入一个字符串。

    * C:把字符串转换为字符数组。

    * D:遍历字符数组获取到每一个字符

    * E:判断该字符是

    * 大写 bigCount++;

    * 小写 smalCount++;

    * 数字 numberCount++;

    * F:输出结果即可

    */

    public class CharacterTest {

    public static void main(String[] args) {

    // 定义三个统计变量。

    int bigCount = 0;

    int smallCount = 0;

    int numberCount = 0;

    // 键盘录入一个字符串。

    Scanner sc = new Scanner(System.in);

    System.out.println("请输入一个字符串:");

    String line = sc.nextLine();

    // 把字符串转换为字符数组。

    char[] chs = line.toCharArray();

    // 历字符数组获取到每一个字符

    for (int x = 0; x < chs.length; x++) {

    char ch = chs[x];

    // 判断该字符

    if (Character.isUpperCase(ch)) {

    bigCount++;

    } else if (Character.isLowerCase(ch)) {

    smallCount++;

    } else if (Character.isDigit(ch)) {

    numberCount++;

    }

    }

    // 输出结果即可

    System.out.println("大写字母:" + bigCount + "个");

    System.out.println("小写字母:" + smallCount + "个");

    System.out.println("数字字符:" + numberCount + "个");

    }

    }

    PS:这里再为大家推荐几款功能相似的在线工具供大家参考:

    希望本文所述对大家java程序设计有所帮助。

    展开全文
  • 包装类用法

    2016-02-14 10:04:07
    import org.omg.CORBA.INTERNAL;... * 测试包装类的基本用法 * @author Administrator * */ public class Test01 { public static void main(String[] args) { Integer i = new Integer(1000)
    package com.MyArray;
    
    import org.omg.CORBA.INTERNAL;
    
    /**
     * 测试包装类的基本用法
     * @author Administrator
     *
     */
    public class Test01 {
    
    	public static void main(String[] args) {
    		Integer i = new Integer(1000);
    		System.out.println(Integer.MAX_VALUE);
    		System.out.println(Integer.toHexString(i));
    		Integer i2 = Integer.parseInt("234");
    		Integer i3 = new Integer("300");
    		System.out.println(i3.intValue());
    		System.out.println(i.intValue());
    	}
    }
    

    展开全文
  • package 包装类;...Wrapper Calss 包装类基本用法 基本数据类型 包装类 byle Byle boolean Boolean 布尔 short Short char Character ** 字符类型 int Integer ** long Long float Fl...

    package 包装类;
    /**

    • Wrapper Calss 包装类基本用法
    • 基本数据类型 包装类
    • byle Byle
    • boolean Boolean 布尔
    • short Short
    • char Character ** 字符类型
    • int Integer **
    • long Long
    • float Float
    • double Double
    • @author Administrator

    */
    public class test01 {
    public static void main(String[] args) {
    Integer i = new Integer(1000);
    System.out.println(Integer.MAX_VALUE);
    System.out.println(Integer.MIN_VALUE);
    System.out.println(Integer.toOctalString(i));//八进制,1750
    System.out.println(Integer.toHexString(i));//十六进制,3e8
    Integer i2 = Integer.parseInt(“234”);//字符串转换成数字
    System.out.println(i2);//234
    System.out.println(i2+10);//244
    //另一种方法转换
    Integer i3 = new Integer(333);
    System.out.println(i3.intValue());//333
    //把数字转换字符串
    String str = 567+"";
    System.out.println(str);
    //把数字转换字符串
    int num = 789;
    String str2 = String.valueOf(num);
    System.out.println(str2);

    }
    

    }

    展开全文
  • 本文实例讲述了Java包装类原理与用法。分享给大家供大家参考,具体如下:产生:为了提高数据类型的的面向对象性,所以产生了包装类包装类中有各种便利的方法数据类型对应的包装类使用:包装类可以实现将基本类型...
  • 主要介绍了Java包装类,结合实例形式分析了Java包装类基本概念、功能、原理、用法及操作注意事项,需要的朋友可以参考下
  • java包装类用法

    2018-09-12 10:27:28
    1. 包装类把基本类型数据转换为对象   1.1每个基本类型在java.lang包中都有一个相应的包装类  2.包装类有何作用  2.1 提供了一系列实用的方法    2.2集合不允许存放基本数据类型数据,存放数字时,要用...
  • 包装类用法

    2014-07-15 17:45:55
    /* JDK1.5版本以后出现的新特性。 */ class IntegerDemo1 { public static void main(String[] args) { // Integer x = new Integer(4); Integer x = 4;//自动装箱。//new Integer(4) .../
  • ATL提供了很多复杂数据类型的包装类,使用这些包装类可以大大减小开发工作量,但是他们使用起来也有许多坑,需要注意,本文就ATL常用包装类用法和坑详细说明,力图说明产生这些坑的原因和使用注意事项。
  • 25. 包装类的基本用法

    2019-07-16 19:54:41
    包装类的基本用法 为什么需要包装类?(Wrapper Class) Java并不是纯面向对象的语言。Java是一个面向对象的语言,但Java中的基本数据类型却不是面向对象的。但是我们在实际使用中经常需要将基本数据类型转换成对象,...
  • java中包装类的比较用法

    千次阅读 2018-01-12 10:14:27
    java中包装类的比较用法 一、前言 java中 ,包装类是一个对象,也是一个具体的数值。对于对象比较可以用 equals()方法,对于数值的比较可以用 == 进行比较,那么对于包装类该用那种方法比较合适呢? ...
  • Java中包装类用法

    2019-10-25 15:10:29
  • 包装类

    2020-11-17 20:16:00
    //包装类用法: //实现类型之间相互转换 //方便对包装类对象进行操作 public class Wraper { public static void main(String args[]) { Integer a = new Integer(10); Integer b = Integer.valueOf(20); //将Integer...
  • 包装类的作用与用法

    2021-03-28 17:37:36
    int i = 10; 我们声明一个基本类型的变量i, 我们可以通过i.xxxx/i.xxx()调用i上面的属性/方法....这8种引用类型就称为8种基本类型的包装! 包装的作用: 1.让我们可以通过对象形式来操作基本
  • 包装实现了基本数据类型,包装类对象,字符串类对象之间的转换关系 基本数据类型 对应的包装类 byte Byte char Character int Integer short Short long Long float Float double Double ...
  • 基本数据类型的包装类 Java是面向对象的编程语言,但他也包含了8种基本数据类型,这8个基本数据类型不支持面向对象的编程机制,基本数据类型的数据也不具备“对象”的特征:没有属性,方法可以被调用; 这8...
  • Optional 对象是一种包装器对象,要么包装对象引用,要么null Optional<String> optionalS = Optional.of(null); // 添加值为null时,抛出异常 Optional<String> optionalSn = Optional.ofNullable(null...
  • API 包装类用法

    2010-01-17 13:57:00
    package joeho.net.csdn.blog;class TestInteger { /** * Method main * * * @param args * */ public static void main(String[] args) { int w = new Integer(args[0]).intValue(); int h = Integer....
  • public class WrapperDemo { /** * @param args */ public static void main(String[] args) { ... * 基本数据类型对象包装类... * 用于描述该对象的类就称为基本数据类型对象包装类。 * * byte By
  • 1.1 包装类我们可以把八个基本数据类型封装到一个类中,在这个类里面我们可以建立许多关于基本数据类型属性和方法。更利于我们对这些数据类型的一些编程。包装类位于java.lang包中。如图所示,我们的数值类型类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,088
精华内容 435
关键字:

包装类用法