精华内容
下载资源
问答
  • 里我们不涉及容器的基本操作之类,只是要讨论一下各个容器其各自的特点。STL中的常用容器包括:顺序性容器(vector、deque、list)、关联容器(map、set)、容器适配器(queue、stac)
  • STL常用容器详细解析

    2021-01-20 06:45:11
    STL中的常用容器包括:顺序性容器(vector、deque、list)、关联容器(map、set)、容器适配器(queue、stac)。 1、顺序性容器 (1)vectorvector是一种动态数组,在内存中具有连续的存储空间,支持快速随机访问。...
  • java 有哪些常用容器(集合)?

    万次阅读 多人点赞 2019-04-29 10:52:47
    java 有哪些常用容器(集合)? java 容器都有哪些? Collection | ├AbstractCollection 对Collection接口的最小化抽象实现 | │ | ├List 有序集合 | │-├AbstractList 有序集合的最小化抽象实现 | │...

    java 有哪些常用容器(集合)?

    java 容器都有哪些?

    Collection

    |  ├AbstractCollection  对Collection接口的最小化抽象实现

    |  │ 

    |  ├List  有序集合

    |  │-├AbstractList  有序集合的最小化抽象实现 

    |  │-├ArrayList  基于数组实现的有序集合

    |  │-├LinkedList  基于链表实现的有序集合

    |  │-└Vector  矢量队列

    |  │ └Stack  栈,先进后出

    |  │

    |  ├Set  不重复集合

    |  │├AbstractSet  不重复集合的最小化抽象实现

    |  │├HashSet  基于hash实现的不重复集合,无序

    |  │├LinkedHashSet  基于hash实现的不重复集合,有序

    |  │└SortedSet  可排序不重复集合

    |  │   └NavigableSet  可导航搜索的不重复集合

    |  │     └TreeSet  基于红黑树实现的可排序不重复集合

    |  │

    |  ├Queue  队列

    |  │├AbstractQueue  队列的核心实现

    |  │├BlockingQueue  阻塞队列

    |  │└Deque  可两端操作线性集合

     

    Map  键值映射集合

    |  ├AbstractMap  键值映射集合最小化抽象实现

    |  ├Hashtable  基于哈希表实现的键值映射集合,key、value均不可为null

    |  ├HashMap  类似Hashtable,但方法不同步,key、value可为null

    |     └LinkedHashMap  根据插入顺序实现的键值映射集合

    |  ├IdentityHashMap  基于哈希表实现的键值映射集合,两个key引用相等==,认为是同一个key

    |  ├SortedMap   可排序键值映射集合

    |     └NavigableMap  可导航搜索的键值映射集合

    |    └WeakHashMap  弱引用建,不阻塞被垃圾回收器回收,key回收后自动移除键值对

     

    可以比较的点:

    • 有序、无序
    • 可重复、不可重复
    • 键、值是否可为null
    • 底层实现的数据结构(数组、链表、哈希...)
    • 线程安全性

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • JAVA 常用容器

    2018-06-19 17:51:01
    常用容器 JComponent是Container的子类,因此JComponent子类创建的组件也都是容器,但我们很少将JButton、JTextFied. JCheckBox等组件当容器来使用。JComponent专门提供了一些经常用来添加组件的容器。相对于JFrame...

    常用容器

          JComponent是Container的子类,因此JComponent子类创建的组件也都是容器,但我们很少将JButton、JTextFied. JCheckBox等组件当容器来使用。JComponent专门提供了一些经常用来添加组件的容器。相对于JFrame底层容器,本节提到的容器被习惯地称为中间容器,中间容器必须被添加到底层容器中才能发挥作用。

    1、JPanel 面板

          经常使用JPanel创建一个面板,再向这个面板添加组件,然后把这个面板添加到其他容器中。JPanel 面板的默认布局是FlowLayout布局。

    2、JTabbedPane选项卡窗格

          可以使用JTabbedPane容器作为中间容器。当用户向JTabbedPane容器添加一个组件时,JTabbedPane容器就会自动为该组件指定一个对应的选项卡,即让个选项卡对应一个组件。各个选项卡对应的组件层叠式放入JTabbedPane容器,当用户单击选项卡时,JTabbedPane容希器将显示该选项卡对应的组件。选项卡默认在JTabbedPane容器的顶部,从左向右依次排列。JTabbedPane容器可以使用

          add(String text, Component c);

    方法将组件c添加到JTabbedPane容器中,并指定和组件c对应的选项卡的文本提示是text。

    可以使用构造方法

          public JTabbedPane (int tabPlacement)

          创建JTabbedPane容器,选项卡的位置由参数tabPlacement 指定,该参数的有效值为JTabbedPane.TOP、JTtabbedPane BOTTOM、JTabbedPane.LEFT 和JTabbedPane.RIGHT.

    3、滚动窗格JScrollPane

          滚动窗格只可以添加一个组件,可以把-个组件放到一个滚动窗格中,然后通过滚动条来观看该组件。JTextArea 不自带滚动条,因此就需要把文本区放到一个滚动窗格中。例如:

          JScrollPane scroll=new JScrollPane (new JTextArea());

    4、拆分窗格JSplitPane

          顾名思义,拆分窗格就是被分成两部分的容器。拆分窗格有两种类型:水平拆分和垂直拆分。水平拆分窗格用一条拆分线把窗格分成左右两部分,左面放一个组件,右面放一个组件,拆分线可以水平移动。垂直拆分窗格用条拆分线把窗格分成上下两部分,上面放一个组件,下面放一个组件,拆分线可以垂直移动。

    JSplitPane的两个常用的构造方法如下:

          JSplitPane(int a, Component b, Component c)

          参数a取JSplitPane的静态常量HORIZONTAL_SPLIT或VERTICAL_SPLIT,以决定是水平还是垂直拆分。后两个参数决定要放置的组件。

          JSplitPane (inta,boolean b,Component c, Component d)

          参数a取JpliPane的静态常量HORIZONTAL_SPLIT或VERTICAL_SPLIT,以决定是水平还是垂直拆分,参数b决定当拆分线移动时,组件是否连续变化(true是连续)。

    5、JLayeredPane分层窗格

          如果添加到容器中的组件经常需要处理重叠问题,就可以考虑将组件添加到分层窗格。分层窗格分成5个层,分层窗格使用

          add (Jcomponent com, int layer);

        添加组件com,并指定com所在的层,其中参数layer的取值为JLayeredPane类中的类常量:DEFAULT_LAYER、PALETTE_LAYER、MODAL_LAYER、POPUP_LAYER、DRAG_LAYER。

          DEFAULT_LAYER层是最底层,添加到DEFAULT_LAYER层的组件如果和其他层的组件发生重叠时,将被其他组件遮挡。DRAG_ LAYER层是最上面的层,如果分层窗格中添加了许多组件,当用户用鼠标移动一组件时,可以把该组件放到DRAG_LAYER层,这样,用户在移动组件的过程中,该组件就不会被其他组件遮挡。添加到同层上的组件,如果发生重叠,后添加的会遮挡先添加的组件。分层窗格调用public void setLayer(Component c,int lay)可以重新设置组件c所在的层,调用public int getLayer(Component C)可以获取组件c所在的层数。

    展开全文
  • C/C++STL常用容器用法总结

    万次阅读 多人点赞 2018-03-30 19:01:43
    一、容器概念:容器是储存其他对象的对象。被储存的对象必须是同一类型。基本特征:以下用X表示容器类型(后面会讲到),T表示储存的对象类型(如int);a和b表示为类型X的值;u表示为一个X容器的标识符(如果X表示...

    一、容器

    概念:容器是储存其他对象的对象。被储存的对象必须是同一类型。

    基本特征:以下用X表示容器类型(后面会讲到),T表示储存的对象类型(如int);a和b表示为类型X的值;u表示为一个X容器的标识符(如果X表示vector<int>,则u是一个vector<int>对象。)

    表 达 式

    返 回 类 型 

    说 明

    复 杂 度

    X::iterator

    指向T的迭代器类型

    满足正向迭代器要求的任何迭代器

    编译时间

    X u

     

    创建一个名为u的空容器

    固定

    X ()

     

    创建一个匿名空容器

    固定

    X u(a)

     

    同X u(a);

    线性

    a.begin()

    迭代器

    返回指向容器第一个元素的迭代器

    固定

    a.end()

    迭代器

    返回指向超尾值的迭代器

    固定

    a.size()

    无符号整型

    返回元素个数

    固定

    a.swap()

    void

    交换a和b内容

    固定

    a == b

    可转换为bool

    如果a和b长度相当且每个元素都相等,则为真

    线性

    a != b

    可转换为bool

    返回!(a == b)

    线性

     

    二、序列容器

    常用容器:vector、deque、list、queue、stack

    概念:序列是对基本容器的一种改进,在保持其基础功能上增加一些我们需要的更为方便的功能。

    要求:序列的元素必须是严格的线性顺序排序。因此序列中的元素具有确定的顺序,可以执行将值插入到特定位置、删除特定区间等操作。

    序列容器基本特征:以下用t表示类型为T(储存在容器中的值的类型)的值,n表示整数,p、q、i和j表示迭代器。

    表 达 式

    返 回 类 型

    说 明

    X a(n,t)

     

    声明一个名为a的由n个t值组成的序列

    X(n,t)

     

    创建一个由n个t值组成的匿名序列

    X a(i,j)

     

    声明一个名为a的序列,并将其初始化为区间[i,j)的内容

    X(i,j)

     

    创建一个匿名序列,并将其初始化为区间[i,j)的内容

    a.insert(p,t)

    迭代器

    将t插入到p的前面

    a.insert(p,n,t)

    void

    将n个t插入到p的前面

    a.insert(p,i,j)

    void

    将区间[i,j)的元素插入到p前面

    a.erase(p)

    迭代器

    删除p所指向的元素

    a.erase(p,q)

    迭代器

    删除区间[p,q)中的元素

    a.clear()

    void

    清空容器

     

    不同容器特有的特征:

    表 达 式

    返 回 类 型

    含 义

    支 持 的 容 器

    a.front()

     

     

    vector、list、deque

    a.back()

     

     

    vector、list、deque

    a.push_front(t)

     

     

    list、deque

    a.push_back(t)

     

     

    vector、list、deque

    a.pop_front(t)

     

     

    list、deque

    a.pop_back(t)

     

     

    vector、list、deque

    a[n]

     

     

    vector、deque

    a.at(t)

     

     

    vector、deque

     

    *a[n]和a.at(n)都返回一个指向容器中第n个元素的引用。区别在于:如果n落在容器有效区间之外,a.at(n)将执行边界检查,并引发out_of_range异常。

    *之所以vector没有push_front(),是因为vector执行此表达式复杂度为线性时间,而deque为固定时间。(这与它们的特性有关,下面讲到)

    (一)vector

    •  vector是最简单也是最重要的一个容器。其头文件为<vector>.
    • vector是数组的一种类表示,它有以下优点:自动管理内存、动态改变长度并随着元素的增减而增大或缩小。
    •  在尾部添加元素是固定时间,在头部或中间添加或删除元素是线性时间。
    • vector是可反转容器。下面以vector为例介绍可反转容器。

    (待补充)

    (二)deque

    • 头文件<deque>
    • 在STL中deque类似vector,并且支持随机访问。区别在于:从deque起始位置插入删除元素时间是固定的。
    •  为了实现在deque俩段执行插入和删除操作的时间为固定这一目的,deque对象设计比vector设计更为复杂一些。因此,在序列中部执行插入删除操作时,vector更快一些。

    (三)list

    • list表示双向链表。头文件<list>
    • list为可反转容器
    • list不支持数组表示法和随机访问。
    • 与矢量迭代器不同,从容器中插入或删除元素之后,链表迭代器指向的元素不变。这与链表的特性有关,删除链表中的元素并不改变其它元素位置,只是修改链接信息。(代码证明)
    • 不同于vector,list不强调随机访问与快速访问,list强调的是元素的快速插入与删除
    • 再次提醒:序列容器都是线性排序,因此list首尾不会相连。
    • list成员函数:

    函 数

    说 明

    void merge(list<T,Alloc>& x)

    将链表x与调用链表合并,俩个链表必须已排序。合并后的经过排序的链表保存在调用链表中,x为空。线性时间。

    void remove(const T & val)

    从链表中删除val的所有实例。线性时间。

    void sort()

    使用<运算符对链表进行排序,复杂度NlogN

    void splice(iterator pos,list<T,Alloc>x)

    将链表x的类容插入到pos前面,x将为空。固定时间。

    void unique()

    将连续相同的元素压缩为单个元素。线性时间。

     放入代码中:

    #include<iostream>
    #include<list>
    #include<iterator> 
    #include<algorithm>
    using namespace std;
    
    void outint(int n){cout << n << " ";}
    
    void Show(list<int> dice,int flag){
    	if(flag)	cout<<"dice = ";
    	else	cout<< " two = ";
    	for_each(dice.begin(),dice.end(),outint);//输出容器的元素。 
    	cout << endl;
    }//此函数用来输出容器元素 
    
    int main()
    {
    	list<int> dice(5,2);//一种赋初值方法。5个2 
    	Show(dice,1);
    	int a[] = {1,5,4,3};
    	dice.insert(dice.begin(),a,a+4);//insert函数用法 
    	Show(dice,1);
    	list<int> two(dice);//另一种赋初值方法,其值与dice相等 
    	Show(two,0);
    	dice.splice(dice.begin(),two);//splice函数用法 
    	Show(dice,1);
    	Show(two,0); //two清空 
    	two = dice;
    	dice.unique();//unique压缩连续相同的元素
    	Show(dice,1);
    	dice.sort();//sort函数用法 
    	two.sort(); 
    	Show(dice,1);
    	Show(two,0); 
    	dice.merge(two);//merge函数用法,将two合并到dice中,two将为空。
    	Show(dice,1);
    	Show(two,0); 
    	dice.remove(2);//移除所有2 
    	Show(dice,1);
    	return 0;
    }

    insert()与splice()之间的不同主要在与:insert()将原始区间的副本插入到目标地址,而splice()则将原始区间移到目标地址。splice()执行后,迭代器仍有效。也就是说原本指向two中一个元素的迭代器,在使用过splice后仍然指向它。

    remove()函数还有更加方便的拓展,将在以后讲到。

    (四)queue

    • 头文件<queue>
    • queue不允许随机访问队列元素,不允许遍历队列,可以进行队列基本操作
    • 可以将元素添加到队尾,从队首删除元素,查看队尾和队首的值,检查元素数目和测试队列是否为空
    • queue的操作:
      方 法说 明
      bool empty()const如果队列为空,则返回true,否则返回false
      size_type size()const返回队列中元素的数目
      T& front()返回指向队首元素的引用
      T& back()返回指向队尾元素的引用
      void push(const T& x)在队尾插入x
      void pop()删除队首元素
      pop()是一个删除数据的方法,不是检索数据的方法。如果要使用队列中的值,首先要使用front()来检索这个值,然后用pop()将他从队列中删除。

    (五)stack

    • 头文件<stack>
    • stack是一个适配器,它给底层类(默认vector)提供典型栈接口。
    • stack不允许随机访问栈元素,不允许遍历栈,把使用限制在定义栈的基本操作上
    • 可以将值压入栈顶,从栈顶弹出元素,查看栈顶的值,检查元素数目,测试栈是否为空
    • stack的操作:
    • 方 法说 明
      bool empty()const如果栈为空,返回true,否则返回false
      size_type size()const返回栈中元素数目
      T& top()返回指向栈顶元素的引用
      void push(const T& x)在栈顶插入x
      void pop()删除栈顶元素
      与queue类似,如果要使用栈中的值,必须首先使用top()来检索这个值,然后使用pop()将它从栈顶删除。

    序列容器还有forword_list(C++11)、priority_queue、array,有兴趣的可以去看一看,但我觉的用的不太常用,不打算整理出来了。

    三、关联容器

    内容太多了,为了美观以及方便查看不得不另起一篇。

    关联容器(map与set)详解



    展开全文
  • Java基础——GUI——Swing中常用容器和组件

    万次阅读 多人点赞 2019-06-20 09:56:08
    1.swing中常用容器 (1)JFrame 常用方法: 1.构造方法: 2.设置窗体可见: 3.设置点击窗体的执行的操作:. 4.设置窗体的大小和位置 等价于上面两个方法 不管窗体多大,窗体运行起来都会出现在...

    1.swing中常用容器

                           

    (1)JFrame

    常用方法:

    • 1.构造方法:
    • 2.设置窗体可见:
    • 3.设置点击窗体的执行的操作:.
    • 4.设置窗体的大小和位置
      •    等价于上面两个方法
      • 不管窗体多大,窗体运行起来都会出现在屏幕的中心
    • 5.获取窗体容器:
      • 在容器中添加和删除组件:
      • 做完添加和删除之后最好刷新容器:
    • 6.设置窗体是否可以改变大小:
    • 7.设置窗体标题:
    • 8.获取窗体的横纵坐标
      • 横坐标:
      • 纵坐标:

    注意:在实际使用JFrame的时候,都是用自定义类来继承JFrame,然后在自定义类的构造方法中对窗体进行初始化

    (2)JDialog

    常用方法与上面类似

    示例代码:保证弹出对话框后阻塞父窗体

    package Demo01;
    
    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    
    public class Demo extends JDialog{
        public Demo(JFrame frame) {
            /*
             *第一个参数:父窗体对象
             *第二个参数:对话框标题
             * 第三个参数:是否阻塞父窗体
             */
            super(frame,"对话框",true);
            //获取对话框窗体容器
            Container c = getContentPane();
            //添加一个对话框
            c.add(new JLabel("这是一个对话框"));
            //设置对话框窗体的坐标和大小
            setBounds(100,100,100,100);
    
        }
    
        public static void main(String[] args) {
            //创建一个窗体
            JFrame f = new JFrame("父窗体");
            //设置窗体的坐标和大小
            f.setBounds(50,50,300,300);
            //获取窗体f的容器
            Container c = f.getContentPane();
            //创建一个按钮
            JButton btn = new JButton("弹出对话框");
            //使用流布局设置布局
            c.setLayout(new FlowLayout());
            //将按钮添加到窗体中
            c.add(btn);
            //设置窗体可见
            f.setVisible(true);
            //设置窗体点击x号关闭程序
            f.setDefaultCloseOperation(EXIT_ON_CLOSE);
            //对按钮添加监听事件
            btn.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    Demo dialog = new Demo(f);
                    dialog.setVisible(true);
                }
            });
        }
    }

    2.Swing中常用组件

                                    

                  

                  

                                           

                                                                         

    (1)JLabel

    作用:在窗体上添加文字或图片

    常用方法:

    import java.awt.Container;
    import java.awt.Cursor;
    import java.awt.Font;
    
    import javax.swing.ImageIcon;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    
    
    public class MyJFrame extends JFrame {
    	//创建标签的引用
    	private JLabel label01;
    	private JLabel label02;
    	
    	//在构造界面的时候就进行初始化界面
    	public MyJFrame() {
    		init();
    	}
    	//初始化界面
    	private void init()
    	{
    		//设置窗体
    		this.setSize(600,400);//设置窗体大小
    		this.setLocationRelativeTo(null);//设置窗体居中显示
    		this.setTitle("JLabel组件");//设置窗体标题
    		this.setDefaultCloseOperation(EXIT_ON_CLOSE);//设置点击窗体x号时退出程序
    		
    		Container container=this.getContentPane();
    		container.setLayout(null);
    		
    		label01 = new JLabel("你好");
    		label01.setSize(200,100);
    		label01.setLocation(0,0);
    		//字体的大小:以磅作为单位
    		//setFont是很多组件都有的
    		label01.setFont(new Font("微软雅黑", Font.BOLD, 40));  
    		
    		
    		label02 = new JLabel();
    		label02.setSize(300,300);
    		label02.setLocation(220,0);
    		//在标签中添加图片
    		//图片本身的像素大小 > 标签的大小:只显示图片的一部分
    		//在实际开发中,我们会首先设计好界面,然后然后确定好图片的大小,用制图软件去改变图片的像素大小
    		label02.setIcon(new ImageIcon("前进.png"));
    		
    		//为鼠标进入标签区域变换形状
    		//Cursor类表示鼠标的各种形状,可以通过Cursor类的静态属性当作参数指定形状
    		label02.setCursor(new Cursor(Cursor.HAND_CURSOR));
    		
    		//为标签添加tip提示框:即鼠标放在标签上,就会显示提示框
    		label02.setToolTipText("这是一个Tip");
    		
    		container.add(label01);
    		container.add(label02);
    	}
    	
    	public static void main(String[] args) {
    		MyJFrame frame =new MyJFrame();
    		frame.setVisible(true);
    	}
    }
    

    (2)文本框JTextField和密码框JPasswordField

    作用:输入单行文本或密码

    常用方法:

    import java.awt.Container;
    import java.awt.Font;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JPasswordField;
    import javax.swing.JTextField;
    
    
    public class MyJFrame extends JFrame {
    	//创建标签的引用
    	private JLabel userName_Label;
    	private JLabel password_Label;
    	private JTextField userName_TextField;
    	private JPasswordField passwordField;
    	private JButton login_Button;
    	private JButton cancel_Button;
     	
    	//在构造界面的时候就进行初始化界面
    	public MyJFrame() {
    		init();
    	}
    	//初始化界面
    	private void init()
    	{
    		//设置窗体
    		this.setSize(600,400);//设置窗体大小
    		this.setLocationRelativeTo(null);//设置窗体居中显示
    		this.setTitle("JLabel组件");//设置窗体标题
    		this.setDefaultCloseOperation(EXIT_ON_CLOSE);//设置点击窗体x号时退出程序
    		
    		Container container=this.getContentPane();
    		container.setLayout(null);
    		
    		//对6个组件进行实例化
    		userName_Label = new JLabel("用户名");
    		password_Label = new JLabel("密码");
    		userName_TextField = new JTextField();
    		passwordField = new JPasswordField();
    		login_Button = new JButton("登录");
    		cancel_Button = new JButton("取消");
    		
    		//设置用户名标签的大小、位置、字体
    		userName_Label.setSize(70,40);
    		userName_Label.setLocation(100,60);
    		userName_Label.setFont(new Font("微软雅黑",Font.PLAIN,20));
    		
    		//设置密码标签的大小、位置、字体
    		password_Label.setSize(70,40);
    		password_Label.setLocation(100,160);
    		password_Label.setFont(new Font("微软雅黑",Font.PLAIN,20));
    		
    		//设置用户名输入框的大小、位置
    		userName_TextField.setSize(300,40);
    		userName_TextField.setLocation(200,60);
    		
    		//设置文本输入框中的限制字符的个数,该方法对null布局不起作用
    		//只能输入5个字符(在非null布局下),但是每个字符的宽度不一样,该方法,以字符m为标准限制字符个数
    		userName_TextField.setColumns(5); 
    		
    		//实现在用户名输入框中按下回车键时,光标切换到密码输入框中
    		userName_TextField.addActionListener(new ActionListener() {  //文本框中使用频率最高的事件是按下回车键
    			
    			@Override
    			public void actionPerformed(ActionEvent e) {
    				//将光标切换到密码框当中
    				passwordField.requestFocus();
    			}
    		});
    		
    		
    		//设置密码输入框的大小、位置
    		passwordField.setSize(300,40);
    		passwordField.setLocation(200,160);
    		//设置密码输入框中的回显字符,即在密码框中显示的字符
    		passwordField.setEchoChar('*');
    		//实现在密码输入框中按下回车后直接登录
    		passwordField.addActionListener(new ActionListener() {
    			
    			@Override
    			public void actionPerformed(ActionEvent e) {
    				login_Button.doClick();  //点击按钮
    			}
    		});
    		
    		//设置登录按钮的大小和位置
    		login_Button.setSize(150,40);
    		login_Button.setLocation(130,240);
    		login_Button.setFont(new Font("微软雅黑",Font.PLAIN,20));
    		
    		//模拟登录
    		login_Button.addActionListener(new ActionListener() {
    			
    			@Override
    			public void actionPerformed(ActionEvent e) {
    				String userName = userName_TextField.getText();
    				String password = new String(passwordField.getPassword());
    				
    				System.out.println("用户名:"+userName);
    				System.out.println("密码:"+password);
    				System.out.println("登录中。。。");
    			}
    		});
    		
    		//设置取消按钮的大小和位置
    		cancel_Button.setSize(150,40);
    		cancel_Button.setLocation(320,240);
    		cancel_Button.setFont(new Font("微软雅黑",Font.PLAIN,20));
    		
    		//将6个组件添加到界面容器当中
    		container.add(userName_Label);
    		container.add(password_Label);
    		container.add(passwordField);
    		container.add(userName_TextField);
    		container.add(login_Button);
    		container.add(cancel_Button);
    	}
    	
    	public static void main(String[] args) {
    		MyJFrame frame =new MyJFrame();
    		frame.setVisible(true);
    	}
    }
    

    (3)文本区JTextArea

    (4)复选框JCheckBox

    复选框和按钮有一个共同的祖先:AbstractButton

    常用方法:

    复选框本身就是一个按钮,只要点在按钮区域点击哪里都是一样的,都会被选中

    import java.awt.Container;
    import java.awt.Font;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.ItemEvent;
    import java.awt.event.ItemListener;
    
    import javax.swing.JButton;
    import javax.swing.JCheckBox;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    
    public class MyJFrame extends JFrame {
    	//作用一:检查框
    	private JCheckBox confirm_CheckBox;
    	private JButton next_Button;
     	
    	//作用二:
    	private String[] city_names;
    	private JCheckBox[] cities_CheckBoxs;
    	private JButton ok_Button;
    	private JLabel cities_Label;
    	
    	
    	//在构造界面的时候就进行初始化界面
    	public MyJFrame() {
    		init();
    	}
    	//初始化界面
    	private void init()
    	{
    		//设置窗体
    		this.setSize(600,400);//设置窗体大小
    		this.setLocationRelativeTo(null);//设置窗体居中显示
    		this.setTitle("复选框演示");//设置窗体标题
    		this.setDefaultCloseOperation(EXIT_ON_CLOSE);//设置点击窗体x号时退出程序
    		
    		Container container=this.getContentPane();
    		container.setLayout(null);
    		
    		//对组件进行实例化
    		confirm_CheckBox = new JCheckBox("我已经阅读并接受条款");
    		next_Button = new JButton("下一步");
    		
    		cities_Label = new JLabel();
    		city_names = new String[]{"北京","上海","广州","深圳"};
    		cities_CheckBoxs = new JCheckBox[city_names.length];
    		ok_Button = new JButton("提交");
    		
    		//设置复选框的大小、位置、字体
    		confirm_CheckBox.setSize(250, 40);
    		confirm_CheckBox.setLocation(30, 30);
    		confirm_CheckBox.setFont(new Font("微软雅黑",Font.PLAIN,20));
    		//设置复选框选中按钮为可用状态,复选框未被选中为不可用状态
    //		confirm_CheckBox.addActionListener(new ActionListener() {
    //			
    //			@Override
    //			public void actionPerformed(ActionEvent e) {
    //				//复选框是否被选中
    //				boolean flag = confirm_CheckBox.isSelected();
    //				next_Button.setEnabled(flag);
    //			}
    //		});
    		
    		confirm_CheckBox.addItemListener(new ItemListener() {
    			
    			@Override
    			public void itemStateChanged(ItemEvent e) {
    				//复选框是否被选中
    				boolean flag = confirm_CheckBox.isSelected();
    				next_Button.setEnabled(flag);
    				
    			}
    		});
    
    		//设置按钮的大小、位置、字体、不可见
    		next_Button.setSize(100, 40);
    		next_Button.setLocation(30, 80);
    		next_Button.setFont(new Font("微软雅黑",Font.PLAIN,20));
    		next_Button.setEnabled(false);
    		
    		
    		//设置标签
    		cities_Label.setSize(200, 40);
    		cities_Label.setLocation(30, 150);
    		cities_Label.setFont(new Font("微软雅黑",Font.PLAIN,20));
    		
    		//设置复选框
    		for(int i=0;i<cities_CheckBoxs.length;i++)
    		{
    			cities_CheckBoxs[i] = new JCheckBox(city_names[i]);
    			cities_CheckBoxs[i].setSize(70, 40);
    			cities_CheckBoxs[i].setLocation(30+i*70,200);
    			cities_CheckBoxs[i].setFont(new Font("微软雅黑",Font.PLAIN,18));
    			container.add(cities_CheckBoxs[i]);
    		}
    		//设置ok按钮
    		ok_Button.setSize(80, 40);
    		ok_Button.setLocation(30, 250);
    		ok_Button.setFont(new Font("微软雅黑",Font.PLAIN,20));
    		//模拟提交
    		ok_Button.addActionListener(new ActionListener() {
    			
    			@Override
    			public void actionPerformed(ActionEvent e) {
    				String string = new String();
    				for(int i=0;i<cities_CheckBoxs.length;i++)
    				{
    					if(cities_CheckBoxs[i].isSelected())
    					{
    						string = string + cities_CheckBoxs[i].getText()+" ";
    					}
    				}
    			}
    		});
    		
    		//将6个组件添加到界面容器当中
    		container.add(confirm_CheckBox);
    		container.add(next_Button);
    		
    		container.add(cities_Label);
    		container.add(ok_Button);
    		
    	}
    	
    	public static void main(String[] args) {
    		MyJFrame frame =new MyJFrame();
    		frame.setVisible(true);
    	}
    }
    

                          

    (5)单选按钮组件

    待补充

    (6)进度条组件

    待补充

    (7)列表框组件JList

    常见方法:

    1)创建列表框

    列表框只是展示数据的窗口,我们看到的列表框的数据并不是来自于列表本身,这些数据来自于它所创建的数据容器

    有三种可以传递给列表的数据容器

    • 第一选择:ListModel(接口):我们可以定义它的实现类DefaultListModel传递给JList的构造方法
    • 第二选择:Vector
    • 第三选择:数组
    import java.awt.Color;
    import java.awt.Container;
    import java.awt.Font;
    import java.util.Vector;
    
    import javax.swing.BorderFactory;
    import javax.swing.DefaultListModel;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JList;
    
    public class MyJFrame extends JFrame {
    	
    	private JLabel select_Label;
    	private JList<String> left_List;
    	
    	//String[] leftData;
    	//Vector<String> leftData;
    	DefaultListModel<String> leftData;
    	
    	//在构造界面的时候就进行初始化界面
    	public MyJFrame() {
    		init();
    	}
    	//初始化界面
    	private void init()
    	{
    		//设置窗体
    		this.setSize(600,400);//设置窗体大小
    		this.setLocationRelativeTo(null);//设置窗体居中显示
    		this.setTitle("创建列表框演示");//设置窗体标题
    		this.setDefaultCloseOperation(EXIT_ON_CLOSE);//设置点击窗体x号时退出程序
    		
    		Container container=this.getContentPane();
    		container.setLayout(null);
    		
    		//要传递给JList的数据容器
    		//leftData = new String[]{"关羽","赵云","黄忠","马超","魏延","张飞"};
    		//leftData =new Vector<String>();  //Vector并不能像数组一次性添加数据,必须通过add方法添加
    		//leftData.add("孙悟空");
    		//leftData.add("猪八戒");
    		//leftData.add("沙僧");
    		leftData = new DefaultListModel<String>();
    		leftData.addElement("孙悟空");
    		leftData.addElement("猪八戒");
    		leftData.addElement("沙僧");
    		//对组件进行实例化
    		select_Label = new JLabel("你准备带谁出征?");
    		//left_List = new JList<String>(leftData);
    		//left_List = new JList<String>();
    		//left_List.setListData(leftData);
    		//left_List = new JList<String>(leftData);
    		left_List = new JList<String>();
    		left_List.setModel(leftData);
    		
    		//设置标签
    		select_Label.setSize(200, 40);
    		select_Label.setLocation(30, 30);
    		select_Label.setFont(new Font("微软雅黑",Font.PLAIN,20));
    		//设置列表
    		left_List.setSize(200, 240);
    		left_List.setLocation(30, 80);
    		left_List.setFont(new Font("微软雅黑",Font.PLAIN,20));
    		left_List.setBorder(BorderFactory.createLineBorder(Color.GRAY,1));
    
    		
    		//将6个组件添加到界面容器当中
    		container.add(select_Label);
    		container.add(left_List);
    	}
    	
    	public static void main(String[] args) {
    		MyJFrame frame =new MyJFrame();
    		frame.setVisible(true);
    	}
    }
    

    2)操作列表框

     

    (8)树形组件JTree


     

    创建树形组件,只能是先添加根结点,然后再逐层去添加子节点

    1)硬编码创建树形组件

    此种方式用户不能新增,删除任何结点

    import java.awt.Container;
    import java.awt.Font;
    import javax.swing.JFrame;
    import javax.swing.JScrollPane;
    import javax.swing.JTree;
    import javax.swing.tree.DefaultMutableTreeNode;
    
    public class MyJFrame extends JFrame {
    	
    	private JTree familyTree;
    	private JScrollPane family_JScrollPane;
    	
    	
    
    	
    	//在构造界面的时候就进行初始化界面
    	public MyJFrame() {
    		init();
    	}
    	//初始化界面
    	private void init()
    	{
    		//设置窗体
    		this.setSize(600,400);//设置窗体大小
    		this.setLocationRelativeTo(null);//设置窗体居中显示
    		this.setTitle("创建列表框演示");//设置窗体标题
    		this.setDefaultCloseOperation(EXIT_ON_CLOSE);//设置点击窗体x号时退出程序
    		
    		Container container=this.getContentPane();
    		container.setLayout(null);
    		
    		//创建一个根节点
    		DefaultMutableTreeNode root = new DefaultMutableTreeNode("曹操");
    		DefaultMutableTreeNode a1 = new DefaultMutableTreeNode("曹昂");
    		DefaultMutableTreeNode a2 = new DefaultMutableTreeNode("曹丕");
    		DefaultMutableTreeNode a3 = new DefaultMutableTreeNode("曹植");
    		DefaultMutableTreeNode a4 = new DefaultMutableTreeNode("曹彰");
    		root.add(a1);
    		root.add(a2);
    		root.add(a3);
    		root.add(a4);
    		DefaultMutableTreeNode b1 = new DefaultMutableTreeNode("曹睿");
    		DefaultMutableTreeNode b2 = new DefaultMutableTreeNode("曹霖");
    		DefaultMutableTreeNode b3 = new DefaultMutableTreeNode("曹志");
    		a2.add(b1);
    		a2.add(b2);
    		a3.add(b3);
    		DefaultMutableTreeNode c1 = new DefaultMutableTreeNode("曹芳");
    		b1.add(c1);
    		
    		
    		//创建树形组件
    		familyTree = new JTree(root);
    		familyTree.setFont(new Font("微软雅黑",Font.PLAIN,20));
    		
    		//创建滚动面板
    		family_JScrollPane = new JScrollPane(familyTree);
    		family_JScrollPane.setSize(300,250);
    		family_JScrollPane.setLocation(30, 30);
    
    		container.add(family_JScrollPane);
    	}
    	
    	public static void main(String[] args) {
    		MyJFrame frame =new MyJFrame();
    		frame.setVisible(true);
    	}
    }
    

    2)动态创建树形组件

    常用方法:

    import java.awt.Container;
    import java.awt.Font;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JScrollPane;
    import javax.swing.JTextField;
    import javax.swing.JTree;
    import javax.swing.event.TreeSelectionEvent;
    import javax.swing.event.TreeSelectionListener;
    import javax.swing.tree.DefaultMutableTreeNode;
    import javax.swing.tree.TreePath;
    import javax.swing.tree.TreeSelectionModel;
    import javax.xml.transform.Templates;
    
    public class MyJFrame extends JFrame {
    	
    	private JTree dynTree;
    	private JScrollPane dyn_JScrollPane;
    	private DefaultMutableTreeNode rooTreeNode;
    	private DefaultMutableTreeNode selectedNode;
    	private JTextField nodeName_TextField;
    	private JButton createButton;
    	private JButton renameButton;
    	private JButton deleteButton;
    	
    	private TreePath path;   //用户选择的结点到根结点的路径
    	
    	//在构造界面的时候就进行初始化界面
    	public MyJFrame() {
    		init();
    	}
    	//初始化界面
    	private void init()
    	{
    		//设置窗体
    		this.setSize(600,400);//设置窗体大小
    		this.setLocationRelativeTo(null);//设置窗体居中显示
    		this.setTitle("创建列表框演示");//设置窗体标题
    		this.setDefaultCloseOperation(EXIT_ON_CLOSE);//设置点击窗体x号时退出程序
    		
    		Container container=this.getContentPane();
    		container.setLayout(null);
    		
    		
    		//实例化组件
    		rooTreeNode = new DefaultMutableTreeNode("根节点");  //创建根节点
    		dynTree = new JTree(rooTreeNode); //创建一颗以rootTreeNode为根节点的树形组件
    		dyn_JScrollPane = new JScrollPane(dynTree);
    		createButton = new JButton("新增");
    		deleteButton = new JButton("删除");
    		renameButton = new JButton("修改");
    		nodeName_TextField = new JTextField();
    		
    		//设置树形组件
    		dynTree.setFont(new Font("微软雅黑",Font.PLAIN,18));
    		  //设置树形组件的单选模式,只能同时被选中一个结点
    		  //先获得树形组件的选择模型对象,然后选择对象模型的单选模式
    		dynTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
    		
    		//为树形组件添加选中结点的监听器
    		dynTree.addTreeSelectionListener(new TreeSelectionListener() {
    			//一旦用户选中结点的状态发生变化,立刻执行此方法
                //用户必须两次选择的结点不同才会起作用,因为这样才代表结点状态改变
    			@Override
    			public void valueChanged(TreeSelectionEvent e) {
    				//当我们从树形组件上选择了一条结点的时候,那么从根结点到它的路径是确定的(因为是单继承)
    				path = e.getPath();  //获得根节点到被选中的结点的唯一路径
    			}
    		});
    		
    		//设置滚动面板
    		dyn_JScrollPane.setSize(350, 250);
    		dyn_JScrollPane.setLocation(200,30);
    		dyn_JScrollPane.setFont(new Font("微软雅黑",Font.PLAIN,18));
    		
    		//设置文本框
    		nodeName_TextField.setSize(80, 30);
    		nodeName_TextField.setLocation(290,300);
    		nodeName_TextField.setFont(new Font("微软雅黑",Font.PLAIN,18));
    		
    		//设置新增按钮
    		createButton.setSize(80, 30);
    		createButton.setLocation(290,300);
    		createButton.setFont(new Font("微软雅黑",Font.PLAIN,18));
    		createButton.addActionListener(new ActionListener() {
    			@Override
    			public void actionPerformed(ActionEvent arg0) {
    				//获得树形组件中被选中的结点
    				//这个方法的返回值是Object类型,此处需要强制类型转换
    				selectedNode = (DefaultMutableTreeNode)dynTree.getLastSelectedPathComponent();		
    				String nameString = nodeName_TextField.getText();
    				
    				if(checkNode_or_checkInput(selectedNode,nameString))
    				{
    					selectedNode.add(new DefaultMutableTreeNode(nameString));
    					//展开被选中结点的路径上的所有结点
    					dynTree.expandPath(path);
    					//当我们给树形组件新增一个结点的时候,树形图上不会立刻显示新增的结点
    					//调用以下方法刷新树形组件
    					dynTree.updateUI();
    					//创建之后清空文本域
    					nodeName_TextField.setText("");
    				}
    
    			}
    		});
    		
    		//设置删除按钮
    		deleteButton.setSize(80, 30);
    		deleteButton.setLocation(380,300);
    		deleteButton.setFont(new Font("微软雅黑",Font.PLAIN,18));
    		deleteButton.addActionListener(new ActionListener() {
    			
    			@Override
    			public void actionPerformed(ActionEvent e) {
    				selectedNode = (DefaultMutableTreeNode)dynTree.getLastSelectedPathComponent();
    				if(selectedNode == null)
    				{
    					System.out.println("请选中一个结点");
    					return;
    				}
    				
    				if(selectedNode.isRoot())
    				{
    					System.out.println("不能删除根节点哦");
    					return;
    				}
    				selectedNode.removeFromParent();
    				dynTree.updateUI();
    			}
    		});
    		
    		//设置修改按钮
    		renameButton.setSize(80, 30);
    		renameButton.setLocation(470,300);
    		renameButton.setFont(new Font("微软雅黑",Font.PLAIN,18));
    		renameButton.addActionListener(new ActionListener() {
    			@Override
    			public void actionPerformed(ActionEvent arg0) {
    				//获得树形组件中被选中的结点
    				//这个方法的返回值是Object类型,此处需要强制类型转换
    				selectedNode = (DefaultMutableTreeNode)dynTree.getLastSelectedPathComponent();
    				String nameString = nodeName_TextField.getText();
    				//不将上述两行代码进行封装的原因是因为上面两行是采集数据,而checkNode_or_checkInput是验证数据
    				//从逻辑上来说,我们不应该把采集数据和验证数据放在一个功能中
    				if(checkNode_or_checkInput(selectedNode,nameString)){
    					selectedNode.setUserObject(nameString);
    					dynTree.updateUI();
    					//修改之后清空文本域
    					nodeName_TextField.setText("");
    				}
    
    
    			}
    		});
    		//设置文本域
    		nodeName_TextField.setSize(80, 30);
    		nodeName_TextField.setLocation(200,300);
    		nodeName_TextField.setFont(new Font("微软雅黑",Font.PLAIN,18));
    
    		//将组件添加到容器中
    		container.add(dyn_JScrollPane);
    		container.add(createButton);
    		container.add(deleteButton);
    		container.add(renameButton);
    		container.add(nodeName_TextField);
    		
    	}
    	
    	public static void main(String[] args) {
    		MyJFrame frame =new MyJFrame();
    		frame.setVisible(true);
    	}
    	
    	//检验用户是否选择了结点或进行了输入
    	private boolean checkNode_or_checkInput(DefaultMutableTreeNode node,String name)
    	{
    		//判断用户是否选择了一个结点
    		if(node == null)
    		{
    			System.out.println("请选择一个结点");
    			return false;
    		}
    		//判断用户是否进行了输入
    		if("".equals(name))
    		{
    			System.out.println("请填写结点名称");
    			return false;
    		}
    		return true;
    	}
    }
    

        

     

     

     

     

     

     

     

     

     

    展开全文
  • Java中三大常用容器体系

    千次阅读 2019-01-19 17:12:07
    一、Java中三种容器区别 二、容器体系 一、Java中三种容器区别 Java中的容器类型包括:List、Set和Map。三种容器的区别: Java中三大容器区别 List Set Map 可以存储重复元素 不可以存储重复元素 ...
  • C++五大常用容器的特性及用途

    千次阅读 2019-03-21 21:39:42
    C++ STL中最基本以及最常用的类或容器无非就是...以上五类常用容器,用法大致相同,当然也有略微不同,因此在学习他们时,要对照相似点,区别不同点,这样就能够快速入门。 我是小白,以下仅是粗浅看法,说的不对...
  • JAVA常用容器的用法[定义].pdf
  • java 容器源码 Java-Container-Source-Code Java常用容器底层源码分析 本项目包含: 各个容器底层源码及注释 还没想到
  • 学习笔记:C#常用容器(集合)

    万次阅读 多人点赞 2019-04-09 09:36:50
    而本文则是主要介绍C#中常用的集合 Array(数组) 相信大家一开始学习的时候接触到的集合就是数组了,他也是最简单的集合。 String [ ] array = new String [ 3 ] ; array [ 0 ] = "张三" ; array [ 1 ...
  • Qt中的常用容器

    万次阅读 2017-03-26 19:47:49
    在Qt库中为我们提供了一系列的基于模板的容器类。这些类可以被用来存储特定类型的项。例如,如果你需要一个大小可以变得QString数组,那么可以使用QVector。
  • 容器图像 常用容器映像的Dockerfile :包含工具的图像。
  • 几种常用容器的分析与比较

    千次阅读 2016-04-27 22:15:37
    stl提供了三个最基本的容器:vector,list,deque。    vector和built-in数组类似,即底层是数组数据结构,线程同步,然而现今被ArrayList代替了,已经很少用了。它拥有一段连续的内存空间,并且起始地址不变,因此...
  • STL — 7个常用容器的区别

    千次阅读 2017-09-11 09:52:32
    7个常用容器的区别   1.STL容器分类: STL的容器可以分为以下几个大类:  一 顺序(序列)容器, 有vector, list
  • Docker容器:Docker常用容器命令

    千次阅读 2021-12-09 16:38:18
    Docker常用容器命令 一.常用容器命令 命令 说明 docker ps 查看运行的容器 docker run xxx xxx运行容器名称或者镜像id 里面还有很多参数到下面会说 docker rm -f xxx 删除容器 xxx是容器名称 -f是强制...
  • STL中常用容器的选择

    千次阅读 2015-05-28 20:02:07
    今天去面试问到了stl的常用容器问题,但是提前没准备,平时也没太在意,还有就是忘了。总之,回答得很狼狈。 希望能在这里整理一下: 1.vector 2.deque 3.list 4.set 5.map 6.stack 7.queue
  • 【C++】STL常用容器总结之一:容器与迭代器

    千次阅读 多人点赞 2016-08-24 22:46:00
    2、由于博主能力有限,对于一些容器的用法可能尚未进行深入研究。因此,本博文若有错误和不足之处,欢迎大家批评指正。 3、本博文仅作学术交流只用,无任何其他用途。言归正传,下面开始介绍C++中的STL容器。1、...
  • C++ STL常用容器

    千次阅读 2019-07-02 15:11:04
    C++的STL中,有哪几种容器容器 在数据存储上,有一种对象类型,它可以持有其它对象或指向其它对像的指针,这种对象类型就叫做容器。 序列容器(7个) vector vector是一段连续的内存地址,基于数组实现,其提供了...
  • 1. 顺序容器2. 容器适配器3. 关联容器 1. 顺序容器   一个容器就是一些特定类型对象的集合。顺序容器(sequential container)为程序员提供了控制元素存储和访问顺序的能力。这种顺序不依赖于元素的值,而是与元素...
  • Docker常用命令及常用容器安装

    千次阅读 2021-12-11 18:21:42
    Docker启动部分 1.启动docker:systemctl start docker ...1、创建并启动容器:docker run --name=容器别名 -d -it -p 主机端口:docker容器端口 -v /宿主机挂载目录:/容器映射目录 --privileged=true
  • 本篇博文主要是通过解析HashMap、ConcurrentHashMap、TreeMap、Hashtable、LinkedHashMap、HashSet、TreeSet 、ArrayList、Vector、LinkedList、BitSet、Pair等常用容器的底层结构来分析各种容器的特点、用途以及...
  • Java开发者Docker常用镜像容器创建
  • list容器 list基本概念 list构造函数 list 赋值和交换 list 大小操作 list 插入和删除 list 数据存取 list容器 list基本概念 功能:将数据进行链式存储 链表(list)是一种物理存储单元上非连续的存储...
  • 10、集合setMap容器是键值对的集合,而set容器只是单纯的键的集合,当只想知道一个值是否存在时,使用set容器是最合适的。在set中,所有元素都会根据其键值被自动排序,同时set中不允许两个元素有相同的键值。1、set...
  • 文章目录 图片用 xmind 绘制出来,然后导出为 png,可放大缩小,里头基本为常用容器然后绘出此图。包括了 List,Set,Map
  • JAVA中常用容器的扩容

    万次阅读 2020-07-26 14:01:16
    容器的容量大于或等于阈(yu,第四声)值(当前容器的容量乘以加载因子的值)的时候,容器就需要自动扩容了。 一、list容器扩容 容器特性:可重复,有序。 1、arrayList:线程不安全,读取速度快。 默认初始容量:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 437,742
精华内容 175,096
关键字:

常用容器

友情链接: getUA.zip