精华内容
下载资源
问答
  • 尝试将一些数据结构用java实现,尝试过程中确实碰到一些问题,收获很大import java.lang.reflect.Array;class ArrayStack {Class type;private T[] values;private int maxSize;private int top;public ArrayStack...

    尝试将一些数据结构用java实现,尝试过程中确实碰到一些问题,收获很大import java.lang.reflect.Array;

    class ArrayStack {

    Class type;

    private T[] values;

    private int maxSize;

    private int top;

    public ArrayStack(Class type, int maxSize) {

    this.type = type;

    this.maxSize = maxSize;

    //values = new T[maxSize];

    values = (T[])Array.newInstance(type, maxSize);

    top = -1;

    }

    public T pop() {

    if(top == -1)

    return null;

    return values[top--];

    }

    public void push(T value) {

    if(top == maxSize-1)

    return;

    values[++top] = value;

    }

    }

    public class Test {

    public static void main(String[] args) {

    ArrayStack stack = new ArrayStack(Integer.class, 10);

    for(int i=0; i<10; i++) {

    stack.push(Integer.valueOf(i));

    }

    for(int i=0; i<10; i++) {

    System.out.println(stack.pop());

    }

    ArrayStack stackOfChars = new ArrayStack(Character.class, 10);

    for(int i=0; i<10; i++) {

    stackOfChars.push((char)(i+65));

    }

    for(int i=0; i<10; i++) {

    System.out.println(stackOfChars.pop());

    }

    }

    }

    展开全文
  • 试用java.util.Stack泛型栈作为父类,用另一个泛型栈对象作为成员变量,模拟实现一个泛型子类Queue,当存储元素的第1个栈的元素超过dump时,再有元素入队列就倒入第2栈。除提供无参构造函数Queue( )外,其它所有队列...
  • java实现泛型栈

    2021-02-12 16:34:24
    public class LinkedStack { private class Node{ U item; Node next; Node(){item=null;next=null;} Node(U item,Node next)... } } 代码如上所示,创建了一个泛型,并且提供pop和push两种操作方法。输出结果如图

    package com.test.common;

    public class LinkedStack {

    private class Node{

    U item;

    Node next;

    Node(){item=null;next=null;}

    Node(U item,Node next)

    {

    this.item=item;

    this.next=next;

    }

    boolean end()

    {

    return item==null && next==null;

    }

    }

    private Node top=new Node();

    public void push(T item)

    {

    top=new Node(item,top);

    }

    public T pop()

    {

    T result=top.item;

    if(!top.end())

    {

    top=top.next;

    }

    return result;

    }

    /**

    * @param args

    */

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    LinkedStack stack=new LinkedStack();

    stack.push("jianghuiwen");

    stack.push("wangjun");

    System.out.println(stack.pop());

    }

    }

    代码如上所示,创建了一个泛型的栈,并且提供pop和push两种操作方法。输出结果如图

    0818b9ca8b590ca3270a3433284dd417.png

    展开全文
  • JAVA泛型应用

    千次阅读 2018-04-27 09:49:08
    从JDK1.5以后引入了三大常用新特性:泛型(Genericity)、枚举(enum)、注解(Annotation)。其中在JDK1.5中泛型是一个非常重要的实现技术,它可以帮助我们解决程序的参数转换问题。 泛型假设需要定义一个描述坐标的...

    从JDK1.5以后引入了三大常用新特性:泛型(Genericity)、枚举(enum)、注解(Annotation)。其中在JDK1.5中泛型是一个非常重要的实现技术,它可以帮助我们解决程序的参数转换问题。

    泛型假设需要定义一个描述坐标的程序类Point,需要提供两个属性x、y。对于这两个属性的内容可能有如下选择:
    x = 10、y = 20 ;
    x = 10.1、y = 20.1 ;
    x = 东经80度、y = 北纬20度
    那么现在首先要解决的问题就是Point类中的x、y的属性类型问题,此时需要保存的有int、double、String,所以 在java中只有一种类型可以保存所有类型:Object型
    这个时候由于设置方的错误,将坐标内容设置成了double与String,但是接收方不知道,于是在执行时就会出现 ClassCastException。 ClassCastException指的是两个没有关系的对象进行强转出现的异常。
    这个时候语法不会对其做任何限制,但执行的时候出现了程序错误,所以得出结论:向下转型是不安全的操作,会带来隐患。

    泛型类的基本使用

    泛型指的就是在类定义的时候并不会设置类中的属性或方法中的参数的具体类型,而是在类使用时再进行定义。
    如果要想进行这种泛型的操作,就必须做一个类型标记的声明。

    class MyClass<T> {
        T value1;
     }
    

    尖括号 <> 中的 T 被称作是类型参数,用于指代任何类型。实际上这个T你可以任意写,但出于规范的目的,Java 还是建议我们用单个大写字母来代表类型参数

    泛型方法

    泛型不仅可以用于定义类,还可以单独来定义方法。如下所示:

    class MyClass{
            public <T> void testMethod(T t) {
                System.out.println(t);
                }
             }
    

    泛型方法与泛型类稍有不同的地方是,类型参数也就是尖括号那一部分是写在返回值前面的。 中的 T 被称为 类型参数,而方法中的 T 被称为参数化类型,它不是运行时真正的参数。
    当然,声明的类型参数,其实也是可以当作返回值的类型的。

    class MyClass{
                public <T> T testMethod(T t) { 
                return t;
                    } 
                }
    

    泛型应用到栈,接收任意数据类型

    之前在应用栈解决括号匹配问题时,为了接收任意类型的数据,将内部设置成了Object,这样虽然解决了任意数据存储问题,但是,随之也带来了问题,之前入栈的是字符,取出来却变成了对象,为了得到字符还得采用一系列复杂的操作,先将其转换成字符串,再转换成字符,曲线救国,char c = stack.stackTop().toString().charAt(0);
    虽然采用这样的方式能得到其中的内容,但是其中存在数据安全问题,假如栈已经存的不再是字符,再对其进行转换,那么就会得到一个错误的结果。
    那么,将泛型引入,最主要的用途就是解决这个类型转换问题
    在接口:

    interface Stack <T>{
    void stackPush(T obj);//入栈
    void stackPop();//出栈
    int size();//栈元素数量
    T stackTop();//取栈顶
    void printStak();//辅助函数,打印栈中元素
    }
    

    以及实现接口时:

    class StackImp <T> implements Stack <T>{
    

    都采用了泛型,这样做的好处就是,在实例化栈这个对象时,我只需要告诉类我要实例化的对象时什么类型就行了:

    Stack<Character> stack = new StackImp<Character>();
    

    这样就不用再顾虑对象取出类型转换问题,一切变得美好而和谐。

    栈中应用泛型并实现括号匹配

    具体相关栈以及应用栈括号匹配:>JAVA栈应用之括号匹配<>JAVA实现动态栈<

    package stack;
    
    
    interface Stack <T>{
    void stackPush(T obj);//入栈
    void stackPop();//出栈
    int size();//栈元素数量
    T stackTop();//取栈顶
    void printStak();//辅助函数,打印栈中元素
    }
    
    class StackImp <T> implements Stack <T>{
    //栈中要有啥?1.元素数量(头节点),里面放栈头和尾巴
    //栈的每个节点放元素和下一个节点的位置
    private int size;
    private Node first;
    private Node last;
    //建一个内部类,实例化节点
    private class Node {//只能此内部访问,private修饰,增强安全性
        private T item;
        private Node next;
        private  Node(T item ,Node next) {//
            this.item = item;
            this.next = next;
            }
        }
        @Override
    public void stackPush(T obj) {
        Node tmp = this.first;
        Node newNode = new Node(obj, null);
        this.last = newNode;
        if (null == this.first) {//首次时
            this.first = newNode;
        }else {
            while (null != tmp.next) {
                tmp = tmp.next;             
            }
            tmp.next = newNode;
        }
        ++ this.size;
    }
    
    @Override
    public void stackPop() {
        Node tmp = this.first;
        if (null == tmp.next) {
            this.first =null;
            this.last = null;
            this.size = 0;
            return ;
        }
        while (null !=tmp.next.next) {
            tmp = tmp.next;
        }
        this.last = tmp;
        tmp.next = null;
        --this.size;
    }
    
    @Override
    public int size() {
        return this.size;
    }
    
    @Override
    public T stackTop() {
        return  (T) this.last.item;//不是返回return this.last啊
    }
    @Override
    public void printStak() {
        Node tmp = this.first;
        if (null == this.first) {
            return;
        }
        while (null != tmp.next) {
            System.out.print(tmp.item + "->");
            tmp = tmp.next;
        }
        System.out.println(tmp.item);
        }
    }
    class Factory{
    public static Stack<Character> getStack() {
        return new StackImp<Character>();
        }
    }
    
    public class Test {
    public static void main(String[] args) {
    //      Stack<Character> stack = Factory.getStack();//工厂产生栈对象
            Stack<Character> stack = new StackImp<Character>();//自己产生栈对象
            String str = "(())hello Jan{{}}";
            bracket(stack, str);
            //括号匹配:左边括号入栈,右边括号,取栈,是一对,pop,不是,return wrong
            //可能会用到 字符串 转字符数组 char [] strarr = str.toCharArray();
    
            //++++++++++栈检测++++++++++
    //          System.out.println(stack.size());
    //          stack.stackPush1("1");
    //          stack.stackPush1("2");
    //          stack.stackPush1("3");
    //          stack.stackPush1("4");
    //          stack.stackPush1("5");
    //          stack.stackPop();
    //          System.out.println(stack.size());
    //          stack.printStak();
    
    }
    public static void bracket (Stack<Character> stack,String str) {
        if (null == str) {
            return ;
        }
        char [] strarr = new char [str.length()];//这里的length()区别于数组中的length,前是方法,后是数组变量
        strarr = str.toCharArray();//直接就放进去了
        int i = 0;//大小写转换 CTRL+ shift x/y
        while (i < strarr.length) {
            //先判断是不是括号,是左括号,入栈
            if ('(' == strarr[i] || '[' == strarr[i] || '{' == strarr [i]) {
                stack.stackPush(strarr[i]);
                ++ i;//前置效率高,不产生临时变量
                continue;//入栈后面就不用再走了
            }
            if (')' == strarr[i] || ']' == strarr[i] || '}' == strarr [i]) {//是右边括号
                 if(stack.size() == 0) {//栈空了,还来右边括号,那右边括号多
                    System.out.println("右括号多");
                    ++ i;
                    return;
                }
                char c = stack.stackTop();//走起.toString().charAt(0) ;
                if ((c == '(' && ')'==  strarr[i]) || ( c == '[' && ']' == strarr[i]) || ( c == '{' && '}' == strarr[i])){
                    stack.stackPop();//栈中的括号与当前匹配
                    ++ i;
                    continue;
                }else {//此时栈中与当前括号不匹配//[}
                    System.out.println("括号不匹配");
                    ++ i;
                    return;
                }
            }
            ++ i;
        }
        if(stack.size() != 0) {//循环结束,要么完全匹配(栈空),要么左边括号多(栈不空),
            System.out.println("左括号多");
            return;
        }
        System.out.println("匹配 =.=");
        }
    }
    

    >源码<
    泛型的出现彻底改变了向下转型的需求。引入泛型后,如果明确设置了类型,则为设置类型:如果没有设置类型,则默认为Object类型。

    展开全文
  • 泛型是JavaSE5.0的重要特性,使用泛型编程...思路分析:既然是用泛型实现结构,那就不能用JDK自带的stack包了,需要自己定义一个结构,比如LinkedList。代码如下:Stack.java:package cn.edu.xidian.crytoll;...

    泛型是Java SE5.0的重要特性,使用泛型编程可以使代码获得最大的重用。由于在使用泛型时要指明泛型的具体类型,这样就避免了类型转换。本实例将使用泛型来实现一个栈结构,并对其进行测试。

    思路分析:既然是用泛型实现栈结构,那就不能用JDK自带的stack包了,需要自己定义一个栈结构,比如LinkedList。

    代码如下:

    Stack.java:

    package cn.edu.xidian.crytoll;

    import java.util.LinkedList;

    public class Stack {

    private LinkedList container = new LinkedList();

    public void push(T t) {

    container.addFirst(t);

    }

    public T pop() {

    return container.removeFirst();

    }

    public boolean empty() {

    return container.isEmpty();

    }

    }

    StackTest.java:

    package cn.edu.xidian.crytoll;

    public class StackTest {

    public static void main(String[] args) {

    Stack stack = new Stack();

    System.out.println("向栈中增加字符串:");

    System.out.println("视频学Java");

    System.out.println("细说Java");

    System.out.println("Java从入门到精通(第2版)");

    stack.push("视频学Java"); //向栈中增加字符串

    stack.push("细说Java"); //向栈中增加字符串

    stack.push("Java从入门到精通(第2版)"); //向栈中增加字符串

    System.out.println("从栈中取出字符串:");

    while (!stack.empty()) {

    System.out.println((String) stack.pop());//删除栈中全部元素并进行输出

    }

    }

    }

    效果如图:

    618435cd3e3fbb8ca24bdae29113585c.png

    展开全文
  • 思路分析:既然是用泛型实现结构,那就不能用JDK自带的stack包了,需要自己定义一个结构,比如LinkedList。代码如下:Stack.java:package cn.edu.xidian.crytoll;import java.util.LinkedList;public class ...
  • 1、泛型的实际应用——实现最小值函数自己设计一个泛型的获取数组最小值的函数,并且数组的元素类型要是Number的子类并且实现了Comparable接口。public >T min(T[] arr) { //因为Number并没有implements ...
  • Java利用泛型实现堆栈

    2021-02-12 16:34:23
    Java传统的下的堆栈是用LinkedList实现的,LinkedList本身已经具备了创建堆栈所必需的方法,而Stack可以通过两个泛型的类Stack和LinkedList的组合来创建。现在我不使用LinkedList,使用泛型来实现自己的内部链式存储...
  • import java.util.Stack; import java.util.NoSuchElementException; public class Queue<E> extends Stack<E>{ public final int dump=1024; private Stack<E> stk; public Queue( ){ /* 在此插入代码*/ } ...
  • java泛型学习总结

    2018-09-19 10:11:04
    1.泛型在集合中的使用(掌握) 2.自定义泛型类、泛型接口、泛型方法(理解 ---&gt;使用) 3.泛型与继承的关系 4.通配符 1.在集合中不使用泛型 public void test1(){  List list = new ArrayList();  list....
  • 题解1 实现内部类node2 维护top为头节点的链表3 操作操作1:push()操作2: pop()操作3: isEmpty()代码package Exam;class MyStackStruct {private class Node {U val;Node next;Node() {this.val = null;...
  • Java泛型与Kotlin泛型

    2021-04-08 12:14:52
    本文主要列举Java泛型与Kotlin泛型的基本知识,以及两者的区别。 什么泛型 泛型程序设计是程序设计的一种风格或或规范。简单的说就是该类型可变,在编写代码时可以根据情况设置不同的类型。因为泛型的可变性,很容易...
  • java实现泛型顺序

    2021-02-12 16:34:23
    java来实现泛型的顺序。/***顺序*@param泛型T*/publicclassSequenceStack{privateT[]data;privateinttop;/***初始化**@paramcapacity*的大小*/publicSequenceStack(intcapacity){data=(T[])newObj...
  • Java-泛型栈

    2018-01-18 21:24:45
    * 泛型栈 * @author 焦焱-16060211104 * * @param <T> 需要存储的类型 */ public class NewStack<T> { private LinkedList<T> St = new LinkedList<T>(); //存数据 /** * 入栈 * @...
  • Java泛型 自定义Stack

    2018-08-10 10:10:04
    public class LinkedStack<T> { //末端哨兵 private static class Node<U> { Node<U> next; U item; Node() { next = null; item = null;...采取了内部类定义一个末端哨兵来判断是否为空。
  • JAVA泛型应用之简单迷宫 将泛型与结合结合之后,可以高效解决一些数据结构中的问题,其中,走迷宫便是我们最常遇到的一类。再此之前,需要对以及泛型有所了解:&gt;JAVA泛型应用&lt; 这里,...
  • 本程序定义了一个泛型栈,可对不同的对象元素进行相同的入栈、出栈、获取栈顶元素、输出栈操作。 package pack2; public class GenericStack<T> { private final int DEFAULT_CAPACITY = 16; //默认容量 ...
  • Java一种机制可以实现,它叫做泛型,也叫做参数化类型。1.2 自动装箱1.4 背包一种不支持从中删除元素的集合数据类型它的目的就是帮助用例收集元素并迭代遍历所有收集到的元素。使用Bag可以说明元素的处理顺序不重要...
  • 一、需求分析 1.1 题目要求 参见https://docs.oracle.com/javase/7/docs/api/java/util/Queue.html,Java...泛型栈作为父类,用另一个泛型栈对象作为成员变量,模拟实现一个泛型子类Queue<E>,当存储元素的...
  • Java泛型和内部类

    2021-09-01 20:16:11
    概念 我们都用过Java集合类,比如 ArrayList、 LinkedList 、HashMap等,都可以用来存放数据,但如果不使用泛型那么就会变成一个通用的集合类。 来看一个列子: public static void main(String[] args) { ArrayList...
  • Java 使用泛型实现堆栈类

    千次阅读 2017-04-16 02:10:16
    Java泛型的一个主要作用就是创造容器类。这里结合泛型实现一个堆栈类。 LinkedStack.java
  • Java 泛型和链表

    2020-07-23 19:43:52
    Java 泛型和链表1. Java的编码方式2. 泛型3. 4.链表 1. Java的编码方式  JVM中,1个字符 = 2个字节 使用Unicode的编码方式  不同的操作系统有不同的编码方式:   Windows:GBK GB2312    1char = 3byte...
  • java泛型方法参数传递

    千次阅读 2021-01-27 01:38:10
    Java参数,不管是原始类型还是引用类型,传递的都是副本(有另外一种说法是传值,但是说传副本更好理解吧,传值通常是相对传址而言)。如果参数类型是原始类型,那么传过来的就是这个参数的一个副本,也就是这个原始...
  • 使用泛型实现结构

    2021-03-21 09:52:33
    泛型类就是含有一个或者多个类型參数的类。定义泛型类非常easy,仅仅须要在类的名称后面加上“”,并在当中指明类型參数,比方本例中的T。也能够在当中指明多个參数,如K、V。多个參数之间使用逗号隔开。定义完类后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,637
精华内容 13,054
关键字:

java泛型栈

java 订阅