extjs 控件事件大全

ExtformTimeField:

配置项：

maxValue：列表中允许的最大时间

maxText：当时间大于最大值时的错误提示信息

minValue：列表中允许的最小时间

minText：当时间小于最小值时的错误提示信息

increment：两个相邻选项间的时间间隔，默认为15分钟

format：显示格式，默认为“g:i A”。一般使用“H:i:s”

H：带前缀0的24小时

i：带前缀0的分钟

s：带前缀0的秒

invalidText：当时间值非法时显示的提示信息

altFormats：多个时间输入格式组成的字符串，不同的格式之间使用“|”进行分割

ExtformFieldSet

animCollapse：动画折叠，默认为false

checkboxToggle：设置是否显示字段集的checkbox选择框，默认为false

checkboxName：指定字段集中用于展开或隐藏字段集面板的checkbox的名字，该属性只有在checkboxToggle为true时生效

labelWidth：字段标签的宽度，可以级联到子容器

layout：布局，默认为form

ExtformDateFied

maxValue：允许选择的最大日期

maxText：当日期大于最大值时的错误提示信息

minValue：允许选择的最小时间

minText：当日期小于最小值时的错误提示信息

format：日期显示格式，默认为“m/d/y”，一般使用“Y-m-d”

Y：四位年份

m：带前缀0的月份

d：带前缀0的日期

y：两位年份

n：不带前缀0的月份

j：不带前缀0的日期

w：星期的数字，0表示星期日，1代表星期一

showToday：是否显示今天按钮，默认为true

altFormats：多个日期输入格式组成的字符串，不同的格式之间使用“|”进行分割，默认值为'm/d/Y|n/j/Y|n/j/y|m/j /y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d'

disabledDates：禁止选择的日期组成的数组

disabledDatesText：选择禁选日期时显示的提示信息

disabledDays：禁止选择的星期组成的数组，0代表星期日，1代表星期一

disabledDaysText：选择禁选星期时显示的提示信息

invalidText：当日期值非法时显示的提示信息

方法：

getValue()：取得日期值

ExtformComboBox

displayField：被显示在下拉框中的字段名

editable：是否可编辑，默认为true

forceSelection：输入值是否严格为待选列表中存在的值。如果输入不存在的值，会自动选择第一个最接近的值。

hiddenName：隐藏字段的名字，如果提供该参数则一个隐藏字段将被创建，用来存储所选值，当表单提交时在服务器端可以通过该名字取得列表中的所选值

listWidth：下拉列表的宽度

minListWidth：下拉列表的最小宽度，默认为70像素

loadingText：当下拉框加载数据时显示的提示信息，只有当mode='remote'时才会生效

maxHeight：下拉列表框的最大高度，默认为300像素

minChars：下拉列表框自动选择前用户需要输入的最小字符数量。mode='remote'默认为4，mode='local'默认为0

mode：下拉列表框的数据读取模式。remote读取远程数据，local读取本地数据

pageSize：下拉列表框的分页大小。该项设置只在mode='remote'时生效

queryParam：查询的名字，默认为'query'，将被传递到查询字符串中

allQuery：一个发往服务器用来查询全部信息的查询字符串，默认为空字符串''

selectOnFocus：当获得焦点时立刻选择一个已存在的列表项。默认为false，此项只有在editable=true时才会生效

store：列表框绑定的数据源

transform：将页面中已存在的元素转换为组合框

lazyInit：延时初始化下拉列表，默认为true

lazyRender：延时渲染，默认为false

triggerAction：设置单击触发按钮时执行的默认操作，有效值包括all和query，默认为query，如果设置为all则会执行allQuery中设置的查询

typeAhead：设置在输入过程中是否自动选择匹配的剩余部分文本（选择第一个满足条件的），默认为false

value：初始化组合框中的值

valueField：组合框的值字段

valueNotFoundText：值不存在时的提示信息

tpl：Ext模板字符串或模板对象，可以通过该配置项自定义下拉列表的显示方式

方法：

clearValue()：清空字段当前值

doQuery( String query, Boolean forceAll )：

getValue()：

getStore()：

setValue( String value )：

ExtfromRadioGroup

allowBlank：

blankText：

ExtformRadio;

getGroupValue()：

setValue( value {String/Boolean} )：

ExtformCheckboxGroup

allowBlank：是否允许不选择，默认为true

blankText：

columns：显示的列数，可选值包括：固定值auto、数值、数组（整数、小数）

items：对象数组

vertical：是否垂直方向显示对象，默认为false

ExtformCheckbox

boxLabel：复选框的文字描述

checked：复选框是否被选择，默认为false

handler：当checked值改变时触发的函数，函数包含两个参数：checkbox、checked

inputValue：

方法：

getValue()：返回复选框的checked状态

setValue( Boolean/String checked )：

ExtformNumberField

allowDecimals：是否允许输入小数，默认为true

allowNegative：是否允许输入负数，默认为true

baseChars：输入的有效数字集合，默认为'0123456789'

decimalPrecision：数字的精度，默认保留小数点后2位

decimalSeparator：十进制分隔符，默认为''

maxValue：允许输入的最大数值

maxText：超过最大值之后的提示信息

minValue：允许输入的最小数值

minText：超过最小值之后的提示信息

nanText：输入非有效数值之后的提示信息

ExtformTextArea

preventScrollbars：是否禁止出现滚动条，默认为false

    如题 有List<String> list 和List<String> list 两个集合各有上万个元素 怎样取出两个集合中不同的元素？    方法 :遍历两个集合         package czp test;import java util ArrayList;import java util List;public class TestList {        public static void main（String[] args） {        List<String> list = new ArrayList<String>（）         List<String> list = new ArrayList<String>（）         for （int i = ; i < ; i++） {        list add（ test +i）         list add（ test +i ）         }        getDiffrent（list list ）         //输出 total times         }        /        获取连个List的不同元素        @param list                 @return        /        private static List<String> getDiffrent（List<String> list List<String> list ） {        long st = System nanoTime（）         List<String> diff = new ArrayList<String>（）         for（String str:list ）        {        if（！ntains（str））        {        diff add（str）         }        }        System out println（ total times +（System nanoTime（） st））         return diff;        }}        千万不要采用这种方法 总共要循环的次数是两个List的size相乘的积 从输出看耗时也是比较长的 那么我们有没有其他的方法呢？当然有

    方法 :采用List提供的retainAll（）方法         package czp test;import java util ArrayList;import java util List;public class TestList {        public static void main（String[] args） {        List<String> list = new ArrayList<String>（）         List<String> list = new ArrayList<String>（）         for （int i = ; i < ; i++） {        list add（ test +i）         list add（ test +i ）         }        getDiffrent（list list ）         //输出 total times         getDiffrent （list list ）         //输出 getDiffrent total times         }        /        获取连个List的不同元素        @param list         @param list         @return        /        private static List<String> getDiffrent （List<String> list List<String> list ） {        long st = System nanoTime（）         list retainAll（list ）         System out println（ getDiffrent total times +（System nanoTime（） st））         return list ;        }        /        获取连个List的不同元素        @param list         @param list         @return        /        private static List<String> getDiffrent（List<String> list List<String> list ） {        long st = System nanoTime（）         List<String> diff = new ArrayList<String>（）         for（String str:list ）        {        if（！ntains（str））        {        diff add（str）         }        }        System out println（ getDiffrent total times +（System nanoTime（） st））         return diff;        }}   

    很遗憾 这种方式虽然只要几行代码就搞定 但是这个却更耗时 查看retainAll（）的源码         public boolean retainAll（Collection<> c） {        boolean modified = false;        Iterator<E> e = iterator（）         while （e hasNext（）） {        if （！ntains（e next（））） {        e remove（）         modified = true;        }        }        return modified;        }        无需解释这个耗时是必然的 那么我们还有没有更好的办法呢？仔细分析以上两个方法中我都做了mXn次循环 其实完全没有必要循环这么多次 我们的需求是找出两个List中的不同元素 那么我可以这样考虑 用一个map存放lsit的所有元素 其中的key为lsit 的各个元素 value为该元素出现的次数 接着把list 的所有元素也放到map里 如果已经存在则value加 最后我们只要取出map里value为 的元素即可 这样我们只需循环m+n次 大大减少了循环的次数         package czp test;import java util ArrayList;import java util HashMap;import java util List;import java util Map;public class TestList {        public static void main（String[] args） {        List<String> list = new ArrayList<String>（）         List<String> list = new ArrayList<String>（）         for （int i = ; i < ; i++） {        list add（ test +i）         list add（ test +i ）         }        getDiffrent（list list ）         //输出 total times         getDiffrent （list list ）         //输出 getDiffrent total times         getDiffrent （list list ）         //输出 getDiffrent total times         }        /        获取连个List的不同元素        @param list         @param list         @return        /        private static List<String> getDiffrent （List<String> list List<String> list ） {        long st = System nanoTime（）         Map<String Integer> map = new HashMap<String Integer>（list size（）+list size（））         List<String> diff = new ArrayList<String>（）         for （String string : list ） {        map put（string ）         }        for （String string : list ） {        Integer cc = map get（string）         if（cc!=null）        {        map put（string ++cc）         continue;        }        map put（string ）         }        for（Map Entry<String Integer> entry:map entrySet（））        {        if（entry getValue（）== ）        {        diff add（entry getKey（））         }        }        System out println（ getDiffrent total times +（System nanoTime（） st））         return list ;        }        /        获取连个List的不同元素        @param list         @param list         @return        /        private static List<String> getDiffrent （List<String> list List<String> list ） {        long st = System nanoTime（）         list retainAll（list ）         System out println（ getDiffrent total times +（System nanoTime（） st））         return list ;        }        /        获取连个List的不同元素        @param list         @param list         @return        /        private static List<String> getDiffrent（List<String> list List<String> list ） {        long st = System nanoTime（）         List<String> diff = new ArrayList<String>（）         for（String str:list ）        {        if（！ntains（str））        {        diff add（str）         }        }        System out println（ getDiffrent total times +（System nanoTime（） st））         return diff;        }}   

    显然 这种方法大大减少耗时 是方法 的 / 是方法 的 / 这个性能的提升时相当可观的 但是 这不是最佳的解决方法 观察方法 我们只是随机取了一个list作为首次添加的标准 这样一旦我们的list 比list 的size大 则我们第二次put时的if判断也会耗时 做如下改进         package czp test;import java util ArrayList;import java util HashMap;import java util List;import java util Map;public class TestList {        public static void main（String[] args） {        List<String> list = new ArrayList<String>（）         List<String> list = new ArrayList<String>（）         for （int i = ; i < ; i++） {        list add（ test +i）         list add（ test +i ）         }        getDiffrent（list list ）         getDiffrent （list list ）         getDiffrent （list list ）         getDiffrent （list list ） //        getDiffrent total times //        getDiffrent total times //        getDiffrent total times //        getDiffrent total times         }        /        获取连个List的不同元素        @param list         @param list         @return        /        private static List<String> getDiffrent （List<String> list List<String> list ） {        long st = System nanoTime（）         Map<String Integer> map = new HashMap<String Integer>（list size（）+list size（））         List<String> diff = new ArrayList<String>（）         List<String> maxList = list ;        List<String> minList = list ;        if（list size（）>list size（））        {        maxList = list ;        minList = list ;        }        for （String string : maxList） {        map put（string ）         }        for （String string : minList） {        Integer cc = map get（string）         if（cc!=null）        {        map put（string ++cc）         continue;        }        map put（string ）         }        for（Map Entry<String Integer> entry:map entrySet（））        {        if（entry getValue（）== ）        {        diff add（entry getKey（））         }        }        System out println（ getDiffrent total times +（System nanoTime（） st））         return diff;        }        /        获取连个List的不同元素        @param list         @param list         @return        /        private static List<String> getDiffrent （List<String> list List<String> list ） {        long st = System nanoTime（）         Map<String Integer> map = new HashMap<String Integer>（list size（）+list size（））         List<String> diff = new ArrayList<String>（）         for （String string : list ） {        map put（string ）         }        for （String string : list ） {        Integer cc = map get（string）         if（cc!=null）        {        map put（string ++cc）         continue;        }        map put（string ）         }        for（Map Entry<String Integer> entry:map entrySet（））        {        if（entry getValue（）== ）        {        diff add（entry getKey（））         }        }        System out println（ getDiffrent total times +（System nanoTime（） st））         return diff;        }        /        获取连个List的不同元素        @param list         @param list         @return        /        private static List<String> getDiffrent （List<String> list List<String> list ） {        long st = System nanoTime（）         list retainAll（list ）         System out println（ getDiffrent total times +（System nanoTime（） st））         return list ;        }        /        获取连个List的不同元素        @param list         @param list         @return        /        private static List<String> getDiffrent（List<String> list List<String> list ） {        long st = System nanoTime（）         List<String> diff = new ArrayList<String>（）         for（String str:list ）        {        if（！ntains（str））        {        diff add（str）         }        }        System out println（ getDiffrent total times +（System nanoTime（） st））         return diff;        }}        这里对连个list的大小进行了判断 小的在最后添加 这样会减少循环里的判断 性能又有了一定的提升 正如一位朋友所说 编程是无止境的 只要你认真去思考了 总会找到更好的方法！ lishixinzhi/Article/program/Java/hx/201311/27046

list=[3,4,5,2,3,4,6]

maxvalue=max(list);

minvalue=min(list);

maxflag=minflag=1

for iflag,i in enumerate(list):

    if i == maxvalue:

        maxflag=iflag

    elif i==minvalue:

        minflag=iflag

temp=list[0]

list[0]=maxvalue

list[maxflag]=temp

temp=list[len(list)-1]

list[len(list)-1]=minvalue

list[minflag]=temp

print(list)

写的有点死板，也没学多久